diff --git a/.changeset/eql-v3-supabase.md b/.changeset/eql-v3-supabase.md new file mode 100644 index 00000000..42a7e4f7 --- /dev/null +++ b/.changeset/eql-v3-supabase.md @@ -0,0 +1,56 @@ +--- +'@cipherstash/stack': minor +'stash': minor +--- + +Add EQL v3 Supabase support, baselined on the `eql-3.0.0-alpha.2` release. + +`@cipherstash/stack/supabase` gains `encryptedSupabaseV3` — the EQL v3 +counterpart of `encryptedSupabase` for schemas authored with +`@cipherstash/stack/eql/v3`. The public surface and call shape are identical +to v2 (same filter methods, `withLockContext`, `audit`); only the schema type +and wire encoding differ. + +**The v3 surface** is the `eql-3.0.0-alpha.2` release artifact: domains use +SQL-standard type names (`eql_v3.integer_ord`, `eql_v3.timestamp_ord`, +`eql_v3.boolean`, … mirrored by `types.IntegerOrd`, `types.TimestampOrd`, +`types.Boolean`, …), SEM internals live in a separate `eql_v3_internal` +schema (grant it roles, never expose it — only `eql_v3` goes in Supabase's +Exposed schemas), and envelopes are versioned `v: 3`. Envelope production +rides on `@cipherstash/protect-ffi` 0.27, which takes an `eqlVersion` so the +same client emits v2 or v3 payloads per schema. + +**Adapter behaviour:** + +- columns are stored in their native `eql_v3.*` domains (raw jsonb payloads, + no composite wrap), with JS property → DB column name resolution and `Date` + reconstruction from `cast_as` on decrypted rows; +- **INTERIM:** filter operands are full storage envelopes — every `eql_v3.*` + domain CHECK requires the storage keys, and the SQL operators coerce their + operand into the domain, so a term-only operand is rejected today. This is + a tracked workaround (Linear CIP-3402), not the design: a full-envelope + operand carries a real decryptable ciphertext plus all of the column's + index terms, and PostgREST filters travel in GET query strings, so operands + can land in URL logs, proxies, and Supabase request logs (query terms are + index-terms-only by design). The fix is an EQL-side term-only scalar query + envelope (the scalar analog of `eql_v3.jsonb_query`); +- `like`/`ilike` on encrypted columns are emitted as PostgREST `cs` + (bloom-filter `@>`) — the v3 domains define no LIKE operator. Substring + search currently also requires `include_original: false` on the match + index; that requirement is a symptom of the same interim full-envelope + operand and goes away with CIP-3402; +- filters on storage-only columns (e.g. `types.Boolean`) and null filter + values are rejected at the type level and at runtime. + +The v3 builder's default row type is exactly the table's inferred plaintext +shape (no index-signature widening — widening would disable the storage-only +filter guard). Filtering or inserting plaintext passthrough columns requires +an explicit row type: `es.from('users', users)`. + +The CLI gains an EQL v3 path: `stash eql install --eql-version 3` installs the +vendored `eql-3.0.0-alpha.2` bundle (`--supabase` selects the opclass-stripped +variant and applies the role grants for both `eql_v3` and `eql_v3_internal`); +`stash db upgrade` also accepts `--eql-version`, and `stash db status` reports +v2 and v3 installs independently. The v2 `SUPABASE_PERMISSIONS_SQL` block is +now generated from a shared `supabasePermissionsSql(schemaName)` helper, with +`SUPABASE_PERMISSIONS_SQL_V3` covering the v3 schemas. diff --git a/.changeset/eql-v3-text-search.md b/.changeset/eql-v3-text-search.md new file mode 100644 index 00000000..1abbb191 --- /dev/null +++ b/.changeset/eql-v3-text-search.md @@ -0,0 +1,18 @@ +--- +"@cipherstash/stack": minor +--- + +Add the EQL v3 `text_search` authoring DSL on a new `@cipherstash/stack/eql/v3` +subpath (`types.TextSearch`, v3 `encryptedTable` / `buildEncryptConfig`). The v3 +builders emit the existing `EncryptConfig` shape, so encryption, payloads, and +query paths are unchanged at runtime. + +Also widens the public client types (`EncryptionClientConfig.schemas`, +`EncryptOptions`, `SearchTerm`/`EncryptQueryOptions`) to a structural contract so +both v2 and v3 builders are accepted by `Encryption` / `encrypt` / `decrypt` / +`encryptQuery`. This is a backward-compatible widening — existing v2 usage is +unaffected. The structural contracts themselves (`BuildableColumn`, +`BuildableQueryColumn`, `BuildableV3QueryableColumn`, `BuildableTable`, +`BuildableTableColumns`) and the `encryptModel` return-type mapper +(`EncryptedFromBuildableTable`) are exported from `@cipherstash/stack/types` so +consumers can name them. diff --git a/.changeset/eql-v3-typed-client.md b/.changeset/eql-v3-typed-client.md new file mode 100644 index 00000000..b8821cf6 --- /dev/null +++ b/.changeset/eql-v3-typed-client.md @@ -0,0 +1,29 @@ +--- +"@cipherstash/stack": minor +--- + +Add a strongly-typed EQL v3 client surface on a new `@cipherstash/stack/v3` +subpath (`EncryptionV3`, `typedClient`, `TypedEncryptionClient`). It re-exports +the v3 `types` namespace and table API (from `@cipherstash/stack/eql/v3`), so a +single import provides everything needed to author and use a v3 schema. + +Every method derives its types from the concrete `table` / `column` builder +arguments: + +- `encrypt` / `encryptQuery` pin the plaintext to the column's domain type + (`text → string`, `int8 → bigint`, `timestamptz → Date`, …). +- `encryptQuery` constrains `queryType` to the column's capabilities and rejects + storage-only columns at compile time. +- `encryptModel` / `bulkEncryptModels` validate schema-column fields against their + inferred plaintext type (passthrough fields are untouched) and return a precise + encrypted model. +- `decryptModel` / `bulkDecryptModels` return the precise plaintext model, + reconstructing `Date` / `bigint` values from the encrypt-config `cast_as`. + +Because the typed methods bind to the concrete branded v3 classes, a hand-rolled +structural table/column is rejected — closing the soundness gap where a non-branded +table could be encrypted at runtime while typed as plaintext. + +Runtime behaviour is unchanged: the encrypt/query paths return the same operations +as the base client; only the model-decrypt paths add a per-column `Date` / `bigint` +reconstruction step. The v2 client surface (`Encryption`) is untouched. diff --git a/.changeset/eql-v3-typed-schema.md b/.changeset/eql-v3-typed-schema.md new file mode 100644 index 00000000..a805d285 --- /dev/null +++ b/.changeset/eql-v3-typed-schema.md @@ -0,0 +1,7 @@ +--- +'@cipherstash/stack': minor +--- + +Add EQL v3 schema builders for all generated SQL domains under `@cipherstash/stack/eql/v3`, exposed as the `types` namespace (one member per EQL v3 domain, e.g. `types.TextEq` / `types.Int4Ord` / `types.Timestamptz`), including explicit query capability metadata (`getQueryCapabilities()` / `isQueryable()`) and v3 table support in model encryption helpers (`encryptModel` / `bulkEncryptModels`). + +Also widen the accepted plaintext input type for `encrypt` / `encryptQuery` to include `Date` and `bigint` (via the new `Plaintext` type), so v3 `date` / `timestamptz` / `int8` domains can be encrypted and queried with their natural JavaScript values. diff --git a/.github/workflows/fta-v3.yml b/.github/workflows/fta-v3.yml new file mode 100644 index 00000000..541ffc33 --- /dev/null +++ b/.github/workflows/fta-v3.yml @@ -0,0 +1,60 @@ +name: "FTA Complexity (EQL v3)" + +# Blocking complexity gate for the EQL v3 text-search schema. Runs the Fast +# TypeScript Analyzer (fta-cli) against the v3 source directory only and fails +# the check when any file exceeds the score cap (`--score-cap` in the +# `analyze:complexity` script). FTA is pure static source analysis, so this job +# needs no build step, database, or credentials. + +on: + push: + branches: + - 'main' + paths: + - 'packages/stack/src/eql/v3/**' + - 'packages/stack/package.json' + - '.github/workflows/fta-v3.yml' + pull_request: + branches: + - "**" + paths: + - 'packages/stack/src/eql/v3/**' + - 'packages/stack/package.json' + - '.github/workflows/fta-v3.yml' + +permissions: + contents: read + +jobs: + fta: + name: Analyze v3 complexity + runs-on: blacksmith-4vcpu-ubuntu-2404 + + steps: + - name: Checkout Repo + uses: actions/checkout@v6 + + - uses: pnpm/action-setup@v6.0.8 + name: Install pnpm + with: + run_install: false + + - name: Install Node.js + uses: actions/setup-node@v6 + with: + node-version: 22 + cache: 'pnpm' + + # node-pty's install hook falls back to `node-gyp rebuild` when no + # linux-x64 prebuild matches. pnpm/action-setup v6 no longer ships + # node-gyp on PATH, so install it explicitly. + - name: Install node-gyp + run: npm install -g node-gyp + + - name: Install dependencies + run: pnpm install --frozen-lockfile + + # Non-zero exit (score above the cap) fails the check — this is the + # blocking gate. No `continue-on-error`. + - name: Analyze v3 complexity + run: pnpm --filter @cipherstash/stack run analyze:complexity diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 26b874b6..3a0b5a59 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -59,12 +59,23 @@ jobs: - name: Install dependencies run: pnpm install --frozen-lockfile + - name: Type tests (stack) + run: pnpm --filter @cipherstash/stack run test:types + - name: Lint — no hardcoded package-manager runners run: pnpm run lint:runners - name: Test — lint script self-tests run: pnpm run test:scripts + # The EQL v3 bundles in packages/cli/src/sql are vendored (derived from + # the stack fixture monolith by gen:eql-v3-sql). Regenerate and fail on + # any diff so the fixture and the shipped bundles cannot drift silently. + - name: Check — vendored EQL v3 SQL bundles are in sync + run: | + pnpm --filter stash run gen:eql-v3-sql + git diff --exit-code -- packages/cli/src/sql/cipherstash-encrypt-v3.sql packages/cli/src/sql/cipherstash-encrypt-v3-supabase.sql + - name: Create .env file in ./packages/protect/ run: | touch ./packages/protect/.env @@ -157,7 +168,7 @@ jobs: run: pnpm exec turbo run test:e2e --filter @cipherstash/e2e # Verifies @cipherstash/stack/wasm-inline works under Deno — i.e. the - # WASM build of protect-ffi 0.25+ and auth 0.38+ can round-trip an + # WASM build of protect-ffi 0.26+ and auth 0.40+ can round-trip an # encryption against ZeroKMS / CTS in a runtime with no native # bindings available. The deno.json deliberately omits --allow-ffi so # a silent fallback to the NAPI module is impossible. diff --git a/docs/query-api-walkthrough.md b/docs/query-api-walkthrough.md new file mode 100644 index 00000000..8559a2ed --- /dev/null +++ b/docs/query-api-walkthrough.md @@ -0,0 +1,77 @@ +# Query API Walkthrough — API → FFI → CipherStash Client + +How a query value travels from the public API down to the Rust SDK across the FFI boundary. Terse by design. + +## Flow + +```mermaid +flowchart TD + subgraph JS["@cipherstash/stack (TypeScript)"] + A["User query builder
ops.eq / Supabase filter / client.encryptQuery()"] + B["EncryptionClient.encryptQuery(value | terms[])
encryption/index.ts:259"] + C["EncryptQueryOperation.execute()
BatchEncryptQueryOperation.execute()"] + D["resolveIndexType() + queryTypeToFfi/QueryOp
build QueryPayload{plaintext,column,table,indexType,queryOp}"] + E["validate: validateNumericValue
assertValueIndexCompatibility"] + end + + subgraph FFI["@cipherstash/protect-ffi (Neon bindings)"] + F["JS wrapper encryptQuery / encryptQueryBulk
lib/index.cjs:155"] + G["native handle via @neon-rs/load
lib/load.cjs:9"] + H["platform .node addon
protect-ffi-darwin-arm64/index.node"] + end + + subgraph RUST["CipherStash Client (Rust SDK)"] + I["EQL term generation
ORE / match / unique / ste_vec"] + J["ZeroKMS key ops"] + end + + A --> B --> C --> E --> D --> F --> G --> H --> I + I --> J + I -- "Encrypted | EncryptedQuery" --> F + F -- "formatEncryptedResult()" --> C + C -- "SQL/PostgREST WHERE clause" --> A +``` + +## Layers + +| # | Layer | Entry point | Role | +|---|-------|-------------|------| +| 1 | Public API | `encryption/index.ts:259/270` `encryptQuery()` | Overloaded: single value → `EncryptQueryOperation`; `ScalarQueryTerm[]` → `BatchEncryptQueryOperation`. | +| 1a | Query builders | `drizzle/operators.ts:976`, `supabase/query-builder.ts:44` | `eq/gt/...` operators & deferred builders that batch-encrypt RHS values, then emit a WHERE clause. | +| 2 | Operations | `operations/encrypt-query.ts:41`, `operations/batch-encrypt-query.ts:115` | `execute()`: validate → resolve index → call FFI. `*WithLockContext` resolves `LockContextInput` via `resolveLockContext` before the FFI call. | +| 3 | EQL resolution | `helpers/infer-index-type.ts:89`, `types.ts:292` | `resolveIndexType` + `queryTypeToFfi`/`queryTypeToQueryOp` map public `QueryTypeName` → FFI `indexType`/`queryOp`. | +| 4 | FFI JS wrapper | `protect-ffi/lib/index.cjs:155` | `encryptQuery`/`encryptQueryBulk` → `wrapAsync(native.*)`. | +| 5 | Native loader | `protect-ffi/lib/load.cjs:9` | `@neon-rs/load` proxies to the platform prebuilt `.node`. | +| 6 | Rust SDK | compiled into `.node` | CipherStash Client: encryption, EQL/ORE/STE-vec term gen, ZeroKMS. Not a JS dep — shipped inside the addon. | + +## Query-type mapping (Layer 3) + +```mermaid +flowchart LR + subgraph Public["QueryTypeName"] + eq[equality] + ord[orderAndRange] + txt[freeTextSearch] + sel[steVecSelector] + trm[steVecTerm] + end + subgraph FFI["indexType / queryOp"] + u[unique] + o[ore] + m[match] + sv[ste_vec] + end + eq --> u + ord --> o + txt --> m + sel --> sv + trm --> sv +``` + +## Notes + +- **Client init:** `EncryptionClient.init()` (`encryption/index.ts:81`) calls FFI `newClient()` once; the returned `Client` handle is passed into every `encryptQuery` call. +- **`cipherstashclient`** = the CipherStash Client **Rust SDK**, compiled via Neon into the platform `.node` binary inside `@cipherstash/protect-ffi`. It performs the actual crypto and talks to ZeroKMS. +- **Result shape:** `EncryptedQueryResult` (`types.ts:175`); shaped by `formatEncryptedResult(..., returnType)` (`eql` vs raw). +- **Version:** `package.json` pins `@cipherstash/protect-ffi@0.24.0` (installed tree observed at `0.23.0` — confirm before relying on it). +- `packages/protect/src/ffi/*` mirrors this flow under the older `protect` package name. diff --git a/docs/reference/supabase-sdk.md b/docs/reference/supabase-sdk.md new file mode 100644 index 00000000..4698b4e6 --- /dev/null +++ b/docs/reference/supabase-sdk.md @@ -0,0 +1,200 @@ +# Supabase SDK reference + +`@cipherstash/stack/supabase` wraps a supabase-js client so encrypted columns +are transparently encrypted on mutations, `::jsonb`-cast on selects, encrypted +in filter terms, and decrypted in results. + +Two entry points, one query mechanism: + +| Entry point | Schema DSL | Column storage | +|---|---|---| +| `encryptedSupabase` | `@cipherstash/stack/schema` (EQL v2) | `eql_v2_encrypted` composite | +| `encryptedSupabaseV3` | `@cipherstash/stack/eql/v3` (EQL v3) | native `eql_v3.*` domains | + +Both filter via **direct EQL operators over PostgREST**: the wrapper encrypts +the filter term and emits an ordinary `col term` filter, which resolves +to the custom operator defined on the encrypted type (equality by HMAC, range +by ORE, free-text by bloom-filter containment). + +## Quick start (EQL v3) + +```typescript +import { Encryption } from '@cipherstash/stack' +import { encryptedTable, types } from '@cipherstash/stack/eql/v3' +import { encryptedSupabaseV3 } from '@cipherstash/stack/supabase' +import { createClient } from '@supabase/supabase-js' + +const users = encryptedTable('users', { + email: types.TextSearch('email'), // eql_v3.text_search + amount: types.IntegerOrd('amount'), // eql_v3.integer_ord +}) + +const supabase = createClient(process.env.SUPABASE_URL!, process.env.SUPABASE_ANON_KEY!) +const client = await Encryption({ schemas: [users] }) +const es = encryptedSupabaseV3({ encryptionClient: client, supabaseClient: supabase }) + +await es.from('users', users).insert({ email: 'a@b.com', amount: 30 }) + +const { data } = await es + .from('users', users) + .select('id, email, amount') + .eq('email', 'a@b.com') + +await es.from('users', users).select('id, amount').gte('amount', 10).lte('amount', 100) +``` + +The builder surface is identical across v2 and v3: +`.select/.insert/.update/.upsert/.delete`, +`.eq/.neq/.in/.like/.ilike/.is/.gt/.gte/.lt/.lte/.match/.or/.not/.filter`, +transforms (`.order/.limit/.range/.single/.maybeSingle/.csv/.abortSignal/.throwOnError`), +plus `.withLockContext(lockContext)` and `.audit(config)`. + +### Typing (v3) + +`es.from('users', users)` infers rows as **exactly** the table's plaintext +shape (schema columns get their domain plaintext types — `types.IntegerOrd` → +`number`, `types.TimestampOrd` → `Date`, …). Storage-only columns (e.g. +`types.Boolean`) are excluded from every filter method — including `.match()` — +at the type level; filtering one is always a clear runtime error. + +Plaintext passthrough columns (`id`, `created_at`, …) are not part of the +default row type, so filtering or inserting them needs an explicit row type +(deliberate: widening the default with an index signature would silently +disable the storage-only guard): + +```typescript +type UserRow = { id: number; email: string; amount: number } +const builder = es.from('users', users) +builder.eq('id', 1) // ok — id is in UserRow +``` + +### Property ↔ DB column names (v3) + +A v3 column can map a JS property to a different DB name: + +```typescript +const events = encryptedTable('events', { + createdAt: types.TimestampOrd('created_at'), +}) +``` + +The adapter resolves the mapping everywhere: filters and mutations address +`created_at`, selects alias it back (`createdAt:created_at::jsonb`), and +result rows are keyed by `createdAt`. `date` / `timestamp` columns decrypt +to real `Date` objects (reconstructed from the encrypt-config `cast_as`). + +## Database setup + +### v3: per-domain columns + +```sql +CREATE TABLE users ( + id SERIAL PRIMARY KEY, + email eql_v3.text_search, + amount eql_v3.integer_ord, + created_at eql_v3.timestamp_ord +); +``` + +The `types.*` member name maps to the domain name: strip the `eql_v3.` prefix +and PascalCase each `_`-separated segment (`types.TextEq` → `eql_v3.text_eq`, +`types.IntegerOrd` → `eql_v3.integer_ord`, `types.Timestamp` → `eql_v3.timestamp`). +The domains use SQL-standard type names (`integer`, `smallint`, `real`, +`double`, `boolean`, `timestamp`). + +### Install EQL + +```bash +# v2 (default) +stash eql install --supabase + +# v3 +stash eql install --eql-version 3 --supabase +``` + +The `--supabase` install uses the opclass-stripped bundle (operator classes / +families require superuser, which Supabase does not grant) and applies the +schema grants for `anon`, `authenticated`, and `service_role`. Without the +grants, encrypted queries fail with `42501`. + +The vendored v3 bundle is the [`eql-3.0.0-alpha.2`](https://github.com/cipherstash/encrypt-query-language/releases/tag/eql-3.0.0-alpha.2) +release artifact. It installs two schemas: `eql_v3` (the column domains and +operators) and `eql_v3_internal` (SEM internals — support functions and types +the domains depend on). The installer applies role grants to **both** schemas; +`eql_v3_internal` needs the grants but must never be exposed (see below). + +### Exposed schemas (manual, required) + +For a bare `col term` filter to reach the custom operator, the EQL schema +(`eql_v2` for v2, `eql_v3` for v3) must be on PostgREST's request-time +search_path — add it to **Dashboard → Settings → API → Exposed schemas** +([Supabase custom-schemas guide](https://supabase.com/docs/guides/api/using-custom-schemas)). + +For v3, expose `eql_v3` **only**. SEM internals live in a separate +`eql_v3_internal` schema precisely so that exposing `eql_v3` (and Supabase's +Table-Builder type picker) surfaces just the column domains — do not add +`eql_v3_internal` to Exposed schemas. It still receives role grants (the +installer applies them); grants and exposure are independent. + +> **Warning — silent fallback.** If the schema is not exposed, the operators +> do not error: comparisons silently fall back to the base jsonb operators and +> return **wrong rows with no error**. After changing the setting, verify with +> a known-value round-trip: insert a row, filter for it by an encrypted +> column, and assert the hit. + +## v3 encoding details + +These are internal to the adapter but explain observable behaviour. Envelopes +(stored payloads and filter operands alike) are versioned `v: 3`. + +- **INTERIM — filter operands are full storage envelopes.** This is a + workaround, not the design, and it is tracked for replacement + (Linear **CIP-3402**). Why it is required today: every `eql_v3.*` domain + CHECK requires the storage keys (`v`/`i`/`c` plus the domain's index terms: + `hm` for `text_eq`, `ob` for `integer_ord`, all three for `text_search`), + and the SQL operator functions coerce their jsonb operand into the domain. + A narrowed query-only term (no ciphertext) fails the CHECK with `23514` for + every domain, so the adapter encrypts each filter value with the full + storage path and the operators extract the term they need + (`eq_term`/`ord_term`/`match_term`). + + **Security caveat:** query terms are supposed to be index-terms-only by + design, but a full-envelope operand carries a real, decryptable ciphertext + `c` plus **all** of the column's index terms — and PostgREST filters travel + in GET query strings, so these envelopes can land in URL logs, intermediate + proxies, and Supabase request logs. The planned fix is an EQL-side + **term-only scalar query envelope** (the scalar analog of the existing + `eql_v3.jsonb_query`) that the domains/operators accept without storage + keys; once it ships, operands stop carrying ciphertext. +- **`like`/`ilike` are emitted as PostgREST `cs`** (`@>` bloom containment) — + the v3 domains define no LIKE operator. Match is tokenized + downcased, so + `like` and `ilike` behave identically; do not include `%` wildcards. +- **INTERIM — free-text search needs `include_original: false`** on the + column's match index for substring patterns to match: + + ```typescript + types.TextSearch('email').freeTextSearch({ include_original: false }) + ``` + + With the default `include_original: true`, the full-envelope operand's bloom + carries the whole pattern as an extra token that only matches when the + pattern equals the stored value. This requirement is a symptom of the same + full-envelope interim mechanism above — a term-only query envelope encodes + the pattern as a query (not as a stored value), so the requirement goes away + with CIP-3402. +- **Mutations send the raw encrypted payload** (the domains are + `DOMAIN … AS jsonb`), unlike v2's `{ data: … }` composite wrap. +- **Null filter values are rejected** with a pointer to `.is(column, null)` — + a null cannot be encrypted into an operand, and silently passing it through + would compare against the jsonb literal `null`. + +## Caveats (shared by v2 and v3) + +- **No `ORDER BY` on encrypted columns.** Operator families need superuser, so + the Supabase install ships without index acceleration and without an + orderable opclass. Range *filtering* (`WHERE col >= term`) works; sorting + does not. OPE index terms that are natively orderable on Supabase (btree + + `ORDER BY`, built-in comparison) are in active development. +- **`select('*')` is rejected** — list columns explicitly so encrypted columns + can be cast. +- **Operator visibility depends on the Exposed-schemas step** (above). diff --git a/docs/superpowers/plans/2026-06-30-eql-v3-text-search-schema-plan.md b/docs/superpowers/plans/2026-06-30-eql-v3-text-search-schema-plan.md new file mode 100644 index 00000000..16c36223 --- /dev/null +++ b/docs/superpowers/plans/2026-06-30-eql-v3-text-search-schema-plan.md @@ -0,0 +1,1223 @@ +# EQL v3 `text_search` Schema DSL Implementation Plan + +> **Superseded (re-baseline, 2026-07-05):** written against the +> pre-`eql-3.0.0-alpha.2` EQL v3 surface — old domain names (`int4`, +> `timestamptz`, …, since renamed to SQL-standard `integer`, `timestamp`, …), +> `v: 2` envelope pins, and no `eql_v3_internal` schema. Retained as a +> historical design record; the shipped surface is the re-baselined one. + +> **Superseded (2026-07-03):** this plan built the DSL on `@cipherstash/stack/schema/v3` +> with `encryptedTextSearchColumn(...)`. That surface has since been renamed to +> `@cipherstash/stack/eql/v3` and the factories replaced by the `types` namespace +> (`types.TextSearch(...)`). Retained as a historical execution record — do not +> re-run against the current tree. + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Add an EQL v3 authoring DSL (`encryptedTextSearchColumn`, plus v3 `encryptedTable` / `buildEncryptConfig`) on a new `@cipherstash/stack/schema/v3` subpath that emits the existing `EncryptConfig` shape with zero native-client changes. + +**Architecture:** A new, self-contained module at `packages/stack/src/schema/v3/index.ts` mirrors the v2 builder structure but exposes one concrete type — `EncryptedTextSearchColumn` — whose capabilities (equality + order/range + free-text match) are baked in. Its `build()` returns the **same** `ColumnSchema` a fully-configured v2 column produces, so the encryption client, payload, and query paths are untouched. The v2 module (`src/schema/index.ts`) is not modified. + +**Tech Stack:** TypeScript (ES2022, bundler module resolution), Zod 3.25.76, Vitest 3, tsup (dual ESM+CJS build), Biome (formatting/lint). + +## Review dispositions + +Code-review feedback verified against the actual files before incorporation. Verdicts and what changed: + +- **[VALID] `token_filters: []` nullish-merge edge is untested.** Confirmed `[] ?? x` evaluates to `[]` (an empty array is not nullish), so an explicit `token_filters: []` DOES override the downcase default through the `?? ` merge. v2 tests this (`schema-builders.test.ts:87-103` passes `token_filters: []` and asserts `[]` survives). The v3 plan's override test (Task 1, Step 1) deliberately omitted `token_filters` and never exercised the explicit-empty-array path. **Change:** added a dedicated `.freeTextSearch({ token_filters: [] })` override test asserting `match.token_filters === []`. +- **[VALID] Repeated `.freeTextSearch()` calls are untested.** Confirmed the sketched v3 `freeTextSearch()` (like v2 `src/schema/index.ts:353-367`) re-merges each call against a fresh defaults object (`defaultMatchOpts()` after the batch-2 factory change), NOT against current state — so `.freeTextSearch({ k: 8 }).freeTextSearch({ m: 4096 })` resets `k` back to `6` (last-call-wins-fully). This matches v2 exactly, so per the "mirror v2 exactly" global constraint we KEEP this behavior rather than switching to merge-against-current (which would diverge from v2). **Change:** added a repeated-call test that pins the v2-consistent last-call-wins-fully semantics. +- **[VALID] Type-level tests don't run in CI (pre-existing repo issue).** Confirmed `vitest.config.ts` has no `typecheck` block, `package.json` `test` script is `vitest run` (no `--typecheck`), and `.github/workflows/tests.yml` runs `pnpm run test`. Vitest only collects `*.test-d.ts` under typecheck mode, so the existing `__tests__/types.test-d.ts` is ALSO unenforced in CI today. **Change:** added Task 4, Step 4 — add a `test:types` package script. (Batch 2 finalizes the CI decision: scope typecheck + wire into CI — see below.) +- **[VALID] Dead-code remap in `InferPlaintext`/`InferEncrypted`.** In v3's flat single-type model `EncryptedV3TableColumn = { [key: string]: EncryptedTextSearchColumn }`, the `as C[K] extends EncryptedTextSearchColumn ? K : never` key-remap filters nothing (every value is already that type). v2 needs the filter because its column map also admits nested-object branches (`src/schema/index.ts:526`, `548`). **Change:** simplified both helpers to `{ [K in keyof C]: string }` / `{ [K in keyof C]: Encrypted }` with a comment marking the filter as a future extension point for when more v3 concrete types land. +- **[VALID] API surface bloat: three ways to read one literal.** v2 exposes column metadata via methods only (`getName()`, `build()` — no getters: `src/schema/index.ts:240-407`). The plan exposed the eql type via a `get eqlType` getter AND `getEqlType()` AND an exported const. **Change (partial):** dropped the `get eqlType` property getter; kept `getEqlType()` (method, matching v2 convention) and the exported `TEXT_SEARCH_EQL_TYPE` const (the single source-of-truth literal, useful for external comparison without instantiation). Updated the constraint, the interface list, and the test that asserted `col.eqlType`. +- **[VALID] Assertions.** **Changes:** switched the load-bearing/default `build()` assertions to `toStrictEqual` (catches stray `undefined` keys); switched the two column-instance type checks from the looser `toMatchTypeOf` to `toEqualTypeOf`; added a negative `@ts-expect-error` type test proving a v2 `EncryptedColumn` is rejected by the v3 `EncryptedV3TableColumn` constraint (v2/v3 column classes carry different private fields, so they are nominally non-assignable — the rejection is real). +- **[VALID] Type tightening.** **Changes:** tightened `InferPlaintext`/`InferEncrypted` constraints from `EncryptedTable` to `EncryptedTable`; inlined the pointless `const castAs: CastAs = 'string'` local into `cast_as: 'string'` (the `ColumnSchema` return type already checks the literal against `CastAs`), and dropped the now-unused `CastAs` import. + +### Batch 2 — scope decision + further review + +**SCOPE DECISION (Option A): v3 must WORK with the client.** This increment now includes widening the public client types so the v3 builders are accepted by `Encryption` / `encrypt` / `decrypt` / `encryptQuery`. Verified the runtime path is purely structural — no `instanceof` anywhere in `src/encryption/operations/*.ts`; the client only reads `column.getName()` (`encrypt.ts:53` etc.), `column.build()` (`encryption/helpers/infer-index-type.ts:11,58`), `table.tableName` (`encrypt.ts:52` etc.), `table.build().columns` (`encryption/helpers/model-helpers.ts:268,566`; dynamodb ops), and `buildEncryptConfig(...schemas)` which calls `tb.build()` (`encryption/index.ts:674`). The blocking types are in `src/types.ts`: `EncryptionClientConfig.schemas` (:98), `EncryptOptions.column`/`table` (:113-114), `SearchTerm` (:123-128) / `QueryTermBase` (:275-280) `.column`/`.table` — all typed against nominal v2 classes (private fields → v3 class not assignable). **Added Task 5** to widen these to a structural contract; runtime is untouched. + +- **[VALID — real latent bug] Shared mutable defaults.** Confirmed in the plan's sketch: `this.matchOpts = { ...DEFAULT_MATCH_OPTS }` is a SHALLOW copy, so the module-level `DEFAULT_MATCH_OPTS.tokenizer` and `.token_filters` (and the `{ kind: 'downcase' }` object inside) are shared by reference across every column built from defaults; `.freeTextSearch()` re-uses those same refs on the `?? ` fallback; and `build()` returns `this.matchOpts` directly. So a caller mutating one built config can mutate the shared defaults used by later columns (cross-column aliasing). **v2 comparison:** v2 (`src/schema/index.ts:353-367`) constructs FRESH inline object literals each `freeTextSearch()` call (no shared module-level const), so it has no cross-column aliasing — but its `build()` still returns `this.indexesValue` by reference, a milder self-aliasing latent issue. Not fixing v2 here. **Change (Task 1):** replaced the `DEFAULT_MATCH_OPTS` const with a `defaultMatchOpts()` factory (fresh nested objects per call) and made `build()` return a deep-cloned `match` block; added a two-column independent-mutation test. +- **[VALID] Missing changeset.** Confirmed the repo uses Changesets (`.changeset/config.json`, sample `.changeset/native-binary-guards.md`). Frontmatter key is the package `name`; `packages/stack/package.json` name is `@cipherstash/stack`. **Change: added Task 6** to create a `.changeset/*.md` with a **minor** bump (additive `./schema/v3` subpath + exports, plus backward-compatible type widening). +- **[VALID] Task 4 TDD label.** "Write the failing type test" contradicted "run to verify it passes" — these type tests are expected green on first run. **Change:** renamed Task 4 Step 1 to "Write type-level regression tests" and adjusted the surrounding wording so the sequencing is honest. +- **[CI — scoped path chosen, with finding] Enforce v3 type tests in CI.** Ran `pnpm exec vitest --run --typecheck __tests__/types.test-d.ts`: the `types.test-d.ts` assertions PASS (18 passed, "Type Errors: no errors"), but the package-wide typecheck surfaces **124 pre-existing "Unhandled Source Error"s** — `src/wasm-inline.ts` can't resolve `@cipherstash/auth/wasm-inline` / `@cipherstash/protect-ffi/wasm-inline` type decls, plus a type mismatch in `__tests__/wasm-inline-normalize.test.ts:69`. Root cause: `tsconfig.json` has NO `include`, so typecheck checks every file. Verified `@/encryption` does NOT import `wasm-inline.ts`, so a typecheck program rooted only at the `*.test-d.ts` files (which import `@/schema`, `@/schema/v3`, `@/types`, `@/encryption`) will not reach the broken modules. **Decision (per coordinator's "scope safely"):** SCOPE Vitest typecheck to the stack package's type-test files via a dedicated narrow `tsconfig.typecheck.json`, add a `test:types` script, and wire THAT into CI — so v3 (and the existing) type tests are enforced without forcing a repo-wide cleanup. The 124 latent wasm-inline typecheck errors are recorded as a flagged follow-up, NOT fixed here. (See Task 4 — scoped config/script in Steps 2-3, CI wiring in Step 5; flag refined in Batch 3 below.) + +### Batch 3 — widen internal consumers + tighten typecheck scoping + +- **[VALID — real gap] Task 5 widened only the public aliases, not the internal consumers.** Verified that widening `EncryptOptions` / `SearchTerm` / `QueryTermBase` to `BuildableColumn` / `BuildableTable` breaks internal code that stores those values into narrow v2-typed fields. Concretely: `operations/encrypt.ts` declares `private column: EncryptedColumn | EncryptedField` (:27) / `private table: EncryptedTable` (:28), assigns `opts.column`/`opts.table` into them (:38-39), and re-exposes them via `getOperation()` (:112-113); `operations/bulk-encrypt.ts` has the same fields (:66-67) plus the module-level `createEncryptPayloads(column: EncryptedColumn | EncryptedField, table: EncryptedTable)` (:28-29); `helpers/infer-index-type.ts` types `inferIndexType` (:10), `validateIndexType` (:55), `resolveIndexType` (:87) as `column: EncryptedColumn` and they are called with the now-widened `term.column` / `opts.column`. **Verified the contract is sufficient (no over-widening / no richer contract needed):** every one of these consumers only ever calls `.getName()`, `.tableName`, and `column.build().indexes` — all present on `BuildableColumn` / `BuildableTable` (`build(): ColumnSchema` exposes `.indexes`). **Verified NOT affected (so we don't over-reach):** `EncryptionClient` stores only `client` + `encryptConfig` (no narrow `schemas` field; methods pass `opts` straight to the operation constructors at `index.ts:203,575,298`), so no client-field change; `operations/encrypt-query.ts` / `batch-encrypt-query.ts` store the *public* widened types (`EncryptQueryOptions` / `ScalarQueryTerm[]`) with no narrow re-declaration, so they need no edit; and the MODEL path (`encrypt-model.ts`, `bulk-encrypt-models.ts`, `model-helpers.ts`) stays narrow (`EncryptedTable` / `EncryptedTable`) because the generic model methods are intentionally NOT widened — so those files are untouched. **Change:** expanded Task 5's file list + steps to also widen `operations/encrypt.ts`, `operations/bulk-encrypt.ts`, and `helpers/infer-index-type.ts` (each with the exact fields/signatures + line refs), with an explicit "do NOT widen the model path" guard. +- **[VALID] `test:types` could run runtime suites.** `vitest --run --typecheck` enables typecheck but still runs the runtime suites too (including credential/network-sensitive ones). Verified the repo's Vitest is **3.2.4** (`package.json` `"vitest": "catalog:repo"` → `3.2.4`), which supports `--typecheck.only`. **Change:** `test:types` is now `vitest --run --typecheck.only` (typecheck enabled, runtime suites skipped), with `tsconfig`/`include` set in `vitest.config.ts`; CI calls the same script. +- **[VALID] First typecheck run was unscoped.** Task 4's old Step 2 ran `vitest --run --typecheck __tests__/schema-v3.test-d.ts` BEFORE the scoped `tsconfig.typecheck.json` existed (created in the old Step 4), so the very first run would hit the 124 unrelated errors. **Change:** reordered Task 4 so the scoped `tsconfig.typecheck.json` + `vitest.config.ts` `typecheck` block + `test:types` script are created FIRST (new Step 2); every typecheck invocation (Task 4 and Task 5's failing-first run) goes through `pnpm run test:types`, which is scoped from the very first run. +- **[VALID] Duplicate `Encrypted` import.** Task 4 Step 1 already adds `import type { Encrypted } from '@/types'`; Task 5 Step 1 repeated it. **Change:** Task 5 now adds ONLY the genuinely new imports (`Encryption, EncryptionClient` from `@/encryption`; `encryptedTable as v2EncryptedTable` extending the existing `@/schema` import) and reuses the already-imported `Encrypted`. + +### Batch 4 — split the query column contract (encryptQuery must reject non-queryable fields) + +- **[VALID — type-safety regression in batch-2/3 widening] `encryptQuery` was widened too far.** Batch 2 widened `SearchTerm.column` / `QueryTermBase.column` from the nominal `EncryptedColumn` to the structural `BuildableColumn`. Verified the problem: `BuildableColumn` (`{ getName(): string; build(): ColumnSchema }`) is INTENTIONALLY also satisfied by v2 `EncryptedField` (confirmed `EncryptedField` at `src/schema/index.ts:197` has `getName()` (:235) and `build()` returning `{ cast_as, indexes: {} }` (:228)) — that structural match is REQUIRED so `encrypt()` can still target nested fields. Side effect: widening the query path to `BuildableColumn` would make `encryptQuery()` type-callable with an `encryptedField(...)`, which has no indexes and which the original nominal `EncryptedColumn` correctly rejected; it would only blow up at runtime ("no indexes configured"). **Fix:** keep `encrypt`'s storage path at `BuildableColumn` (columns AND fields), but give the query path its own narrower contract `BuildableQueryColumn = EncryptedColumn | (BuildableColumn & { getEqlType(): string })`. Verified `getEqlType()` is a sound discriminator: a `grep` for `getEqlType` across `src/` returns nothing today (v3 not implemented), v2 `EncryptedColumn`/`EncryptedField` do NOT declare it, and only v3 `EncryptedTextSearchColumn` will — so the nominal arm admits v2 queryable columns, the structural arm admits v3 queryable columns, and `EncryptedField` (no `getEqlType`, not an `EncryptedColumn`) is excluded. Verified the narrowing is safe for the storage path: the `infer-index-type.ts` functions batch-3 widened (`inferIndexType`/`validateIndexType`/`resolveIndexType`) are reached ONLY via `resolveIndexType`, imported solely by `operations/encrypt-query.ts` (:72,:165) and `operations/batch-encrypt-query.ts` (:51) — NOT by `encrypt.ts`/`bulk-encrypt.ts` — so narrowing them to `BuildableQueryColumn` cannot break field encryption. **Change:** `SearchTerm.column` + `QueryTermBase.column` → `BuildableQueryColumn`; `EncryptOptions.column` stays `BuildableColumn`; the three `infer-index-type.ts` signatures take `BuildableQueryColumn` (not `BuildableColumn`); added negative (`encryptQuery` rejects a field) + positive (`encrypt` accepts a field; `encryptQuery` accepts v2 column and v3 column) type tests. + - **Follow-up flagged (not blocking):** `getEqlType()` works as the queryability discriminator only because the sole v3 type shipping is `text_search`, which is queryable. If a future v3 *non-queryable* concrete type also carries `getEqlType()`, the structural arm would wrongly admit it. When such a type lands, switch the discriminator to a queryability-specific marker (e.g. a `readonly __queryable` brand or an explicit capability method) rather than the generic `getEqlType()`. Kept `getEqlType()` for now. + +### Batch 5 — pin the bulk-encrypt widen-site + note the WASM v3 boundary + +- **[VALID — should-fix] `bulk-encrypt.ts` widen-site was vague + mislabeled.** The batch-3 step covered the `column`/`table` re-exposure only via a conditional ("if the `*WithLockContext` variant re-exposes … widen those too") with no line ref and the wrong owning class. Verified the real site: it is `BulkEncryptOperation.getOperation()`'s RETURN TYPE at `src/encryption/operations/bulk-encrypt.ts:141-142` (`column: EncryptedColumn | EncryptedField` (:141), `table: EncryptedTable` (:142)) — destructured and consumed by `BulkEncryptOperationWithLockContext.execute()` at :168 (uses only `.getName()` / `.tableName`). It is NOT a member of the `*WithLockContext` class. **Change:** rewrote the `bulk-encrypt.ts` step to pin `:141-142` as a REQUIRED widen-site on `BulkEncryptOperation.getOperation()`, with the corrected class label, so an implementer can't leave `bulk-encrypt.ts` red. +- **[VALID — flag, not blocking] WASM-inline path does not accept v3 columns.** Verified `src/wasm-inline.ts:314-320`: `getColumnName(col: EncryptOptions['column'])` does `if (col instanceof EncryptedColumn || col instanceof EncryptedField) return col.getName(); throw …`. Confirmed (a) it STILL type-checks after the `EncryptOptions['column']` widening — an `instanceof` guard narrowing a wider union is valid TS; and (b) it is OUTSIDE the scoped typecheck graph (`@/encryption` doesn't import `wasm-inline.ts`; the `test:types` tsconfig roots only the `*.test-d.ts` files), so it does NOT make the package red. But a v3 column routed through the WASM-inline entry would hit the `else throw` at RUNTIME. This is consistent with the batch-2 "no `instanceof`" finding being explicitly scoped to `operations/*.ts`. **Change:** added a note to Task 5 (Step 3b) and the spec's known-boundaries that the WASM-inline entry does not yet accept v3 columns — a deferred, documented boundary, not a latent surprise. + +### Batch 6 — `Required` vs an explicit built type + +- **[REFUTED as a bug → applied as robustness] `Required` could fail typecheck.** The finding claimed that because `matchIndexOptsSchema` fields are `.default(...).optional()` (`src/schema/index.ts:99-105`), `Required<>` might not strip `undefined` and the plan's `defaultMatchOpts()` / `matchOpts` spread-clone could fail declaration/build typecheck. **Verified and refuted under this repo's actual config:** + - `tsconfig.json` sets `strict: true`, has **no `extends`** (no base tsconfig), and does **NOT** set `exactOptionalPropertyTypes`. + - TS's `-?` mapped modifier (`Required = { [K]-?: T[K] }`) DOES strip `undefined` when `exactOptionalPropertyTypes` is off. Reproduced empirically with the repo's TypeScript **5.9.3**: a faithful replica of the plan's exact pattern (`Required` factory + private field + the `build()` spread/clone of `tokenizer`/`token_filters` + `.map()` + non-`undefined` assignments) compiles with **ZERO errors** under `--strict` (no EOPT). It only errors (TS2532 / TS2322) when `--exactOptionalPropertyTypes` is forced on — which the repo does not use. + - **v2 precedent confirms it:** v2 already declares `match?: Required` (`src/schema/index.ts:246`, not `:247` — `:247` is `ste_vec`) and the package builds/ships under this tsconfig. So `Required` works in-repo today; the "can fail typecheck" premise is false here. + - **Decision (robustness, NOT a fix):** still adopted `BuiltMatchIndexOpts` (`{ tokenizer: NonNullable; … }`) for `defaultMatchOpts()`'s return type and the private `matchOpts` field, because it states non-null intent explicitly and is decoupled from `Required<>`'s `exactOptionalPropertyTypes`-dependent subtlety. Verified empirically that this explicit type compiles clean BOTH without AND with `exactOptionalPropertyTypes` (so it also future-proofs the new module against a later strictness bump, which `Required` would not survive). The public tuning input stays `MatchIndexOpts` (all-optional); only the internal resolved shape uses `BuiltMatchIndexOpts`. The emitted `build()` shape is unchanged (a fully-required object is assignable to the optional `ColumnSchema.indexes.match`). + +### Batch 7 — `@ts-expect-error` placement in the Batch-4 negative test + +- **[VALID — real defect] Batch-4 negative test placed `@ts-expect-error` on the wrong line.** The Batch-4 test put `// @ts-expect-error` directly above the `client.encryptQuery('…', {` call line, but the `EncryptedField`-not-assignable-to-`BuildableQueryColumn` error is a DEEP object-literal property mismatch that tsc reports on the inner `column:` argument line, not the call's first line. Since `@ts-expect-error` only suppresses the immediately-following line, the directive would be unused → **TS2578 "Unused '@ts-expect-error' directive"** AND the real error would leak from the `column:` line → `schema-v3.test-d.ts` goes red. (Hazard compounded: an implementer "fixing" the TS2578 by deleting the directive would silently delete the negative guarantee.) **Reproduced empirically** with the repo's TypeScript **5.9.3**: directive-above-the-call → TS2578 (at the directive line) + TS2741 (at the `column:` line); directive-directly-above-`column:` (multi-line) or a collapsed one-line call → both clean (no TS2578, no leak). **Fix (Variant B):** moved the `@ts-expect-error` to sit directly above the `column: v2usersWithField.profile.email,` line (kept the call multi-line), matching the placement style of Task 4's negative test, and added an inline comment explaining the deep-property-line requirement. +- **Audit of all other `@ts-expect-error` directives in the plan:** the only other one is Task 4's "rejects a v2 `EncryptedColumn` in a v3 table" test — verified it ALREADY sits directly above the offending `email: encryptedColumn('email'),` property line (the generic-constraint mismatch lands there), so it is correctly placed and needs no change. No other mis-placed directives found. + +## Global Constraints + +- **Do NOT change** the v2 module's (`packages/stack/src/schema/index.ts`) runtime behavior or the shape of its existing exported symbols. The DSL additions are purely additive. The ONLY permitted edit to this file is a backward-compatible **widening** of `buildEncryptConfig`'s parameter type to the shared structural `BuildableTable` contract (Task 5) — a pure widening (existing callers still type-check) required so the client accepts both v2 and v3 tables. (If the team prefers zero v2 edits, the documented fallback in Task 5 is to assemble the config inline in `Encryption()` instead.) +- **Runtime is structural and unchanged.** The encrypt/decrypt/query path reads only `column.getName()`, `column.build()`, `table.tableName`, `table.build().columns` — no `instanceof`. Client integration is achieved by widening the public TYPES (Task 5), not by a runtime rewrite. +- v3 builders MUST emit the existing `ColumnSchema` / `EncryptConfig` shape imported from `@/schema` — reuse the v2 types, do not redefine them. +- `cast_as` MUST be the SDK-facing literal `'string'` (NOT `'text'`). `toEqlCastAs` is a v2/wasm-inline concern and is out of scope here. +- Match-index defaults MUST mirror the v2 `freeTextSearch()` builder **exactly**: `tokenizer: { kind: 'ngram', token_length: 3 }`, `token_filters: [{ kind: 'downcase' }]`, `k: 6`, `m: 2048`, `include_original: true`. (Note: `include_original` is `true` — the v2 builder default, not the zod-schema default of `false`.) +- `unique.token_filters` defaults to `[]` (case-sensitive equality, matching v2). +- `.freeTextSearch(opts?)` is **tuning only** — it overrides match-index params and NEVER enables a capability. Merge semantics are per-top-level-key replace against the defaults (mirror v2's `opts?.x ?? default`). +- `EncryptedTextSearchColumn` records the eql type `'eql_v3.text_search'`, exposed via the `getEqlType()` method ONLY (no property getter — methods-not-getters matches the v2 builder convention). The single source-of-truth literal is the exported `TEXT_SEARCH_EQL_TYPE` const. This value is metadata for future increments and MUST be absent from `build()` output. +- v3 `encryptedTable` and `buildEncryptConfig` intentionally shadow the v2 symbol names; they live only on the `/v3` subpath. `buildEncryptConfig` emits `{ v: 1, tables }`. +- Tests live in `packages/stack/__tests__/`, named `*.test.ts` (runtime) and `*.test-d.ts` (type-level, run via the scoped `test:types` script with `--typecheck.only` — Task 4). Source imports use the `@/` alias (`@/schema`, `@/schema/v3`, `@/types`). +- Run all commands from `packages/stack/` unless noted. The test runner is `pnpm exec vitest`. +- Keep changes Biome-clean (2-space indent, single quotes, no semicolons — match the surrounding files). + +## File Structure + +- **Create:** `packages/stack/src/schema/v3/index.ts` — the entire v3 DSL: `EncryptedTextSearchColumn`, v3 `EncryptedTable`, `encryptedTextSearchColumn`, `encryptedTable`, `buildEncryptConfig`, `InferPlaintext`, `InferEncrypted`, and the `EncryptedV3TableColumn` shape type. Single focused file (the spec allows splitting later if it grows). +- **Create:** `packages/stack/__tests__/schema-v3.test.ts` — runtime behavior tests. +- **Create:** `packages/stack/__tests__/schema-v3.test-d.ts` — type-level inference tests. +- **Modify:** `packages/stack/tsup.config.ts` — add `src/schema/v3/index.ts` to the main config's `entry` array. +- **Modify:** `packages/stack/package.json` — add the `./schema/v3` export, `typesVersions` entry, and a `test:types` script. +- **Modify:** `packages/stack/src/types.ts` — define the structural `BuildableColumn` / `BuildableTable` contract and widen `EncryptionClientConfig.schemas`, `EncryptOptions`, `SearchTerm` / `QueryTermBase` to it (Task 5). +- **Modify:** `packages/stack/src/schema/index.ts` — backward-compatible widening of `buildEncryptConfig`'s parameter type ONLY (Task 5; see Global Constraints for the fallback). +- **Modify:** `packages/stack/src/encryption/operations/encrypt.ts`, `.../operations/bulk-encrypt.ts` (storage path → `BuildableColumn` / `BuildableTable`) and `.../helpers/infer-index-type.ts` (query path → `BuildableQueryColumn`) — widen the internal consumers of the widened public types (Task 5, Step 3b). +- **Create:** `packages/stack/tsconfig.typecheck.json` — narrow tsconfig (roots = `__tests__/**/*.test-d.ts`) so Vitest typecheck enforces the type tests without dragging in the 124 pre-existing wasm-inline errors (Task 4). +- **Modify:** `packages/stack/vitest.config.ts` — add a `typecheck` block (include `__tests__/**/*.test-d.ts`, `tsconfig: './tsconfig.typecheck.json'`) (Task 4). +- **Modify:** `.github/workflows/tests.yml` — run the scoped type tests in CI (Task 4). +- **Create:** `.changeset/.md` — minor bump for `@cipherstash/stack` (Task 6). + +--- + +### Task 1: `EncryptedTextSearchColumn` builder + +**Files:** +- Create: `packages/stack/src/schema/v3/index.ts` +- Test: `packages/stack/__tests__/schema-v3.test.ts` + +**Interfaces:** +- Consumes (from v2, `@/schema`): `type ColumnSchema`, `type MatchIndexOpts`, the runtime builder `encryptedColumn` (test only, for the equivalence assertion). (`CastAs` is NOT consumed — `build()` emits the bare `'string'` literal, checked by the `ColumnSchema` return type.) +- Produces: + - `class EncryptedTextSearchColumn` with: + - `constructor(columnName: string)` + - `freeTextSearch(opts?: MatchIndexOpts): this` + - `build(): ColumnSchema` + - `getName(): string` + - `getEqlType(): 'eql_v3.text_search'` (method only — no `get eqlType` property getter) + - `function encryptedTextSearchColumn(columnName: string): EncryptedTextSearchColumn` + - `const TEXT_SEARCH_EQL_TYPE = 'eql_v3.text_search'` (exported const literal) + +- [ ] **Step 1: Write the failing tests** + +Create `packages/stack/__tests__/schema-v3.test.ts`: + +```ts +import { describe, expect, it } from 'vitest' +import { encryptedColumn } from '@/schema' +import { + EncryptedTextSearchColumn, + encryptedTextSearchColumn, +} from '@/schema/v3' + +describe('eql_v3 text_search column', () => { + it('returns an EncryptedTextSearchColumn with the correct name', () => { + const col = encryptedTextSearchColumn('email') + expect(col).toBeInstanceOf(EncryptedTextSearchColumn) + expect(col.getName()).toBe('email') + }) + + it('.build() emits the pinned default config (cast_as: string + all three indexes)', () => { + const built = encryptedTextSearchColumn('email').build() + // toStrictEqual (not toEqual) so a stray `undefined` key would fail. + expect(built).toStrictEqual({ + cast_as: 'string', + indexes: { + unique: { token_filters: [] }, + ore: {}, + match: { + tokenizer: { kind: 'ngram', token_length: 3 }, + token_filters: [{ kind: 'downcase' }], + k: 6, + m: 2048, + include_original: true, + }, + }, + }) + }) + + it('LOAD-BEARING: default build() deep-equals the v2 equality+order+match column', () => { + const v3 = encryptedTextSearchColumn('email').build() + const v2 = encryptedColumn('email') + .equality() + .orderAndRange() + .freeTextSearch() + .build() + // toStrictEqual: byte-identical, no extra/undefined keys on either side. + expect(v3).toStrictEqual(v2) + }) + + it('.freeTextSearch(opts) overrides each provided key and keeps the rest as defaults', () => { + const built = encryptedTextSearchColumn('email') + .freeTextSearch({ + tokenizer: { kind: 'ngram', token_length: 4 }, + k: 8, + m: 4096, + include_original: false, + }) + .build() + expect(built.indexes.match).toEqual({ + tokenizer: { kind: 'ngram', token_length: 4 }, + // omitted -> default downcase filter retained + token_filters: [{ kind: 'downcase' }], + k: 8, + m: 4096, + include_original: false, + }) + }) + + it('.freeTextSearch({ token_filters: [] }) overrides the downcase default with an empty array', () => { + // LOAD-BEARING: `[] ?? default` evaluates to `[]` (an empty array is not + // nullish), so an explicit empty array must OVERRIDE the downcase default, + // not fall back to it. Mirrors v2 (schema-builders.test.ts). + const built = encryptedTextSearchColumn('email') + .freeTextSearch({ token_filters: [] }) + .build() + expect(built.indexes.match.token_filters).toEqual([]) + }) + + it('repeated .freeTextSearch() calls are last-call-wins-fully (each re-merges against defaults, not prior state)', () => { + // Each call re-merges against a fresh defaultMatchOpts(), not the + // accumulated matchOpts — so the second call resets k back to its default + // of 6. This is intentional: it mirrors v2 exactly. Pinned here so a future + // "merge against current state" change can't silently slip in. + const built = encryptedTextSearchColumn('email') + .freeTextSearch({ k: 8 }) + .freeTextSearch({ m: 4096 }) + .build() + expect(built.indexes.match.k).toBe(6) + expect(built.indexes.match.m).toBe(4096) + }) + + it('.freeTextSearch() is tuning-only: unique and ore indexes stay present', () => { + const built = encryptedTextSearchColumn('email') + .freeTextSearch({ k: 8 }) + .build() + expect(built.indexes.unique).toEqual({ token_filters: [] }) + expect(built.indexes.ore).toEqual({}) + }) + + it('getEqlType() returns the concrete domain name', () => { + const col = encryptedTextSearchColumn('email') + expect(col.getEqlType()).toBe('eql_v3.text_search') + }) + + it('eqlType metadata is absent from build() output', () => { + const built = encryptedTextSearchColumn('email').build() + expect(built).not.toHaveProperty('eqlType') + expect(Object.keys(built).sort()).toEqual(['cast_as', 'indexes']) + }) + + it('built columns share no mutable state: mutating one build() output does not affect another', () => { + // Guards against the shared-defaults aliasing bug: defaults come from a + // per-instance factory and build() deep-clones the match block. + const a = encryptedTextSearchColumn('a').build() + const b = encryptedTextSearchColumn('b').build() + + // Mutate every nested level of a's match block. + a.indexes.match.k = 999 + a.indexes.match.token_filters.push({ kind: 'downcase' }) + a.indexes.match.tokenizer = { kind: 'standard' } + + expect(b.indexes.match.k).toBe(6) + expect(b.indexes.match.token_filters).toEqual([{ kind: 'downcase' }]) + expect(b.indexes.match.tokenizer).toEqual({ kind: 'ngram', token_length: 3 }) + + // A second build() of an independent column is also pristine. + const c = encryptedTextSearchColumn('c').build() + expect(c.indexes.match.k).toBe(6) + expect(c.indexes.match.token_filters).toEqual([{ kind: 'downcase' }]) + }) +}) +``` + +- [ ] **Step 2: Run the tests to verify they fail** + +Run: `pnpm exec vitest run __tests__/schema-v3.test.ts` +Expected: FAIL — module resolution error `Failed to resolve import "@/schema/v3"` (the file does not exist yet). + +- [ ] **Step 3: Create the v3 module with the column builder** + +Create `packages/stack/src/schema/v3/index.ts`: + +```ts +import type { ColumnSchema, MatchIndexOpts } from '@/schema' + +/** + * The concrete EQL v3 domain name for a full-capability text column. + * Recorded as metadata for future DDL / query-dialect increments; it is + * intentionally absent from the emitted encrypt config. + */ +export const TEXT_SEARCH_EQL_TYPE = 'eql_v3.text_search' + +/** + * Fully-resolved match-index options: every field present and non-`undefined`. + * + * `MatchIndexOpts` (the user-facing tuning input) has all fields optional — + * each is `.default(...).optional()` in the zod schema, so its inferred type is + * `T | undefined`. This type pins the BUILT/resolved shape explicitly via + * `NonNullable<...>`, which states the non-null intent directly and is robust + * regardless of `Required<>`'s subtle, `exactOptionalPropertyTypes`-dependent + * stripping semantics. (v2 uses `Required` and that compiles + * fine under this repo's tsconfig — `strict: true`, NO `exactOptionalPropertyTypes` + * — so this is a clarity/robustness choice, not a fix for a present break.) + */ +type BuiltMatchIndexOpts = { + tokenizer: NonNullable + token_filters: NonNullable + k: NonNullable + m: NonNullable + include_original: NonNullable +} + +/** + * Default match-index parameters. These mirror the v2 `freeTextSearch()` + * builder defaults EXACTLY (note `include_original: true`, which is the v2 + * builder default rather than the zod-schema default of `false`). + * + * This is a FACTORY (not a shared `const`) so every caller gets fresh, unaliased + * nested objects (`tokenizer`, `token_filters` and the `{ kind: 'downcase' }` + * inside it). A shared const would be shallow-copied by `{ ...DEFAULT }`, leaving + * those nested objects aliased across every column — a caller mutating one built + * config could then corrupt the defaults used by later columns. + */ +function defaultMatchOpts(): BuiltMatchIndexOpts { + return { + tokenizer: { kind: 'ngram', token_length: 3 }, + token_filters: [{ kind: 'downcase' }], + k: 6, + m: 2048, + include_original: true, + } +} + +/** + * Builder for an `eql_v3.text_search` column. + * + * The concrete type inherently enables equality + order/range + free-text + * match — there are no capability-enabling methods. `.freeTextSearch(opts?)` + * tunes the match index only. + */ +export class EncryptedTextSearchColumn { + private readonly columnName: string + private matchOpts: BuiltMatchIndexOpts + + constructor(columnName: string) { + this.columnName = columnName + this.matchOpts = defaultMatchOpts() + } + + /** + * The concrete EQL v3 domain name. Metadata only; not emitted by `build()`. + * Method (not a property getter) to match the v2 builder convention. + */ + getEqlType(): typeof TEXT_SEARCH_EQL_TYPE { + return TEXT_SEARCH_EQL_TYPE + } + + /** + * Tune the match index. Each provided key replaces its default; omitted + * keys keep the default. This NEVER enables a capability — match is always + * on for this type. Merge semantics mirror v2's `opts?.x ?? default`. + */ + freeTextSearch(opts?: MatchIndexOpts): this { + // A fresh defaults object per call supplies the `?? ` fallbacks, so no + // nested default object is ever shared into `this.matchOpts` by reference. + const defaults = defaultMatchOpts() + this.matchOpts = { + tokenizer: opts?.tokenizer ?? defaults.tokenizer, + token_filters: opts?.token_filters ?? defaults.token_filters, + k: opts?.k ?? defaults.k, + m: opts?.m ?? defaults.m, + include_original: opts?.include_original ?? defaults.include_original, + } + return this + } + + /** Emit the encrypt-config column. Byte-identical to a v2 equality+order+match column. */ + build(): ColumnSchema { + // `cast_as` is typed `CastAs` by the `ColumnSchema` return type, so the + // literal is checked here without a redundant local annotation. + // + // Deep-clone the match block so the returned config NEVER aliases this + // builder's internal `matchOpts` (or any caller-supplied opts merged into + // it). A caller mutating the returned object cannot corrupt this builder's + // state or another column's defaults. + return { + cast_as: 'string', + indexes: { + unique: { token_filters: [] }, + ore: {}, + match: { + ...this.matchOpts, + tokenizer: { ...this.matchOpts.tokenizer }, + token_filters: this.matchOpts.token_filters.map((f) => ({ ...f })), + }, + }, + } + } + + getName(): string { + return this.columnName + } +} + +/** + * Define an `eql_v3.text_search` column. The concrete type carries all three + * capabilities (equality + order/range + free-text match). Chain + * `.freeTextSearch(opts)` to tune the match index. + */ +export function encryptedTextSearchColumn( + columnName: string, +): EncryptedTextSearchColumn { + return new EncryptedTextSearchColumn(columnName) +} +``` + +- [ ] **Step 4: Run the tests to verify they pass** + +Run: `pnpm exec vitest run __tests__/schema-v3.test.ts` +Expected: PASS (all 10 tests in this describe block green). + +- [ ] **Step 5: Commit** + +```bash +git add packages/stack/src/schema/v3/index.ts packages/stack/__tests__/schema-v3.test.ts +git commit -m "feat(stack): add eql_v3 text_search column builder" +``` + +--- + +### Task 2: v3 `encryptedTable`, `buildEncryptConfig`, and inference helpers + +**Files:** +- Modify: `packages/stack/src/schema/v3/index.ts` (append table + config + inference) +- Test: `packages/stack/__tests__/schema-v3.test.ts` (append `describe` blocks) + +**Interfaces:** +- Consumes (from v2, `@/schema`): `type ColumnSchema`, `type EncryptConfig`, `encryptConfigSchema` (test only). From `@/types`: `type Encrypted`. +- Consumes (from Task 1): `EncryptedTextSearchColumn`, `encryptedTextSearchColumn`. +- Produces: + - `type EncryptedV3TableColumn = { [key: string]: EncryptedTextSearchColumn }` + - `class EncryptedTable` with `tableName: string`, `columnBuilders: T`, and `build(): { tableName: string; columns: Record }` + - `function encryptedTable(tableName: string, columns: T): EncryptedTable & T` + - `function buildEncryptConfig(...tables: Array>): EncryptConfig` + - `type InferPlaintext>` → `{ [col]: string }` + - `type InferEncrypted>` → `{ [col]: Encrypted }` + +- [ ] **Step 1: Write the failing tests** + +Append to `packages/stack/__tests__/schema-v3.test.ts`. First add `encryptConfigSchema` to the existing `@/schema` import and the table symbols to the `@/schema/v3` import, so the file header becomes: + +```ts +import { describe, expect, it } from 'vitest' +import { encryptConfigSchema, encryptedColumn } from '@/schema' +import { + buildEncryptConfig, + EncryptedTable, + EncryptedTextSearchColumn, + encryptedTable, + encryptedTextSearchColumn, +} from '@/schema/v3' +``` + +Then append these `describe` blocks at the end of the file: + +```ts +describe('eql_v3 encryptedTable', () => { + it('creates a table exposing column builders as properties', () => { + const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), + }) + expect(users).toBeInstanceOf(EncryptedTable) + expect(users.tableName).toBe('users') + expect(users.email).toBeInstanceOf(EncryptedTextSearchColumn) + }) + + it('table.email returns the same builder instance passed in', () => { + const emailCol = encryptedTextSearchColumn('email') + const users = encryptedTable('users', { email: emailCol }) + expect(users.email).toBe(emailCol) + }) + + it('build() assembles { tableName, columns } with built column configs', () => { + const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), + }) + const built = users.build() + expect(built.tableName).toBe('users') + expect(built.columns).toStrictEqual({ + email: { + cast_as: 'string', + indexes: { + unique: { token_filters: [] }, + ore: {}, + match: { + tokenizer: { kind: 'ngram', token_length: 3 }, + token_filters: [{ kind: 'downcase' }], + k: 6, + m: 2048, + include_original: true, + }, + }, + }, + }) + }) +}) + +describe('eql_v3 buildEncryptConfig', () => { + it('produces a { v: 1, tables } config', () => { + const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), + }) + const config = buildEncryptConfig(users) + expect(config.v).toBe(1) + expect(config.tables).toHaveProperty('users') + expect(config.tables.users).toHaveProperty('email') + }) + + it('emits a config that passes encryptConfigSchema.parse()', () => { + const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), + }) + const config = buildEncryptConfig(users) + expect(() => encryptConfigSchema.parse(config)).not.toThrow() + }) + + it('supports multiple tables', () => { + const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), + }) + const posts = encryptedTable('posts', { + body: encryptedTextSearchColumn('body'), + }) + const config = buildEncryptConfig(users, posts) + expect(Object.keys(config.tables).sort()).toEqual(['posts', 'users']) + }) +}) +``` + +- [ ] **Step 2: Run the tests to verify they fail** + +Run: `pnpm exec vitest run __tests__/schema-v3.test.ts` +Expected: FAIL — `buildEncryptConfig`, `EncryptedTable`, and `encryptedTable` are not exported from `@/schema/v3` (import errors / `is not a function`). + +- [ ] **Step 3: Append the table, config builder, and inference helpers** + +Append to `packages/stack/src/schema/v3/index.ts`. First extend the import at the top of the file so it reads: + +```ts +import type { + ColumnSchema, + EncryptConfig, + MatchIndexOpts, +} from '@/schema' +import type { Encrypted } from '@/types' +``` + +Then append after `encryptedTextSearchColumn`: + +```ts +/** + * Shape of v3 table columns: every value is a top-level + * {@link EncryptedTextSearchColumn}. (Nested fields and other v3 concrete + * types are deferred to later increments.) + */ +export type EncryptedV3TableColumn = { + [key: string]: EncryptedTextSearchColumn +} + +interface TableDefinition { + tableName: string + columns: Record +} + +/** + * A v3 encrypted table. Mirrors the v2 `EncryptedTable` but only accepts v3 + * column builders. Emits the same `{ tableName, columns }` definition shape. + */ +export class EncryptedTable { + /** @internal Type-level brand so TypeScript can infer `T` from `EncryptedTable`. */ + declare readonly _columnType: T + + constructor( + public readonly tableName: string, + public readonly columnBuilders: T, + ) {} + + build(): TableDefinition { + const builtColumns: Record = {} + for (const [colName, builder] of Object.entries(this.columnBuilders)) { + builtColumns[colName] = builder.build() + } + return { + tableName: this.tableName, + columns: builtColumns, + } + } +} + +/** + * Define a v3 encrypted table. Intentionally shadows the v2 `encryptedTable` + * name but lives on the `/v3` subpath — the importer picks the model by import + * path. The returned object is also a column accessor (`users.email`). + */ +export function encryptedTable( + tableName: string, + columns: T, +): EncryptedTable & T { + const tableBuilder = new EncryptedTable( + tableName, + columns, + ) as EncryptedTable & T + + for (const [colName, colBuilder] of Object.entries(columns)) { + ;(tableBuilder as EncryptedV3TableColumn)[colName] = colBuilder + } + + return tableBuilder +} + +/** + * Build an `EncryptConfig` (`v: 1`) from one or more v3 tables. Emits the same + * shape as v2's `buildEncryptConfig`. + */ +export function buildEncryptConfig( + ...tables: Array> +): EncryptConfig { + const config: EncryptConfig = { + v: 1, + tables: {}, + } + + for (const tb of tables) { + const tableDef = tb.build() + config.tables[tableDef.tableName] = tableDef.columns + } + + return config +} + +/** + * Infer the plaintext (decrypted) shape from a v3 table schema. + * + * In v3's flat single-type column model every value is an + * {@link EncryptedTextSearchColumn}, so no key-remap filter is needed — every + * column maps to `string`. When future v3 increments add other concrete column + * types (or nested fields), reintroduce a `[K in keyof C as C[K] extends ... ]` + * filter here. + */ +export type InferPlaintext> = + T extends EncryptedTable ? { [K in keyof C]: string } : never + +/** + * Infer the encrypted shape from a v3 table schema. See {@link InferPlaintext} + * for why no key-remap filter is needed in the flat single-type model. + */ +export type InferEncrypted> = + T extends EncryptedTable ? { [K in keyof C]: Encrypted } : never +``` + +Note: `CastAs` is intentionally NOT imported — Task 1's `build()` emits the bare `'string'` literal (checked by the `ColumnSchema` return type), so no `CastAs` annotation is needed anywhere in this module. + +- [ ] **Step 4: Run the tests to verify they pass** + +Run: `pnpm exec vitest run __tests__/schema-v3.test.ts` +Expected: PASS (all runtime tests across both describe groups green). + +- [ ] **Step 5: Commit** + +```bash +git add packages/stack/src/schema/v3/index.ts packages/stack/__tests__/schema-v3.test.ts +git commit -m "feat(stack): add eql_v3 encryptedTable and buildEncryptConfig" +``` + +--- + +### Task 3: Wire the `./schema/v3` export subpath + +**Files:** +- Modify: `packages/stack/tsup.config.ts` (add the v3 entry) +- Modify: `packages/stack/package.json` (`exports` + `typesVersions`) + +**Interfaces:** +- Consumes: the module from Tasks 1-2 at `src/schema/v3/index.ts`. +- Produces: external import path `@cipherstash/stack/schema/v3` resolving to `dist/schema/v3/index.{js,cjs,d.ts,d.cts}`. + +- [ ] **Step 1: Add the v3 build entry to tsup** + +In `packages/stack/tsup.config.ts`, find the `entry` array of the FIRST (main) config object and add the v3 path. Change: + +```ts + 'src/schema/index.ts', + 'src/drizzle/index.ts', +``` + +to: + +```ts + 'src/schema/index.ts', + 'src/schema/v3/index.ts', + 'src/drizzle/index.ts', +``` + +- [ ] **Step 2: Add the `./schema/v3` export to package.json** + +In `packages/stack/package.json`, in the `exports` object, add a `./schema/v3` entry immediately after the existing `./schema` block: + +```json + "./schema/v3": { + "import": { + "types": "./dist/schema/v3/index.d.ts", + "default": "./dist/schema/v3/index.js" + }, + "require": { + "types": "./dist/schema/v3/index.d.cts", + "default": "./dist/schema/v3/index.cjs" + } + }, +``` + +(Place it between the `./schema` block and the `./types` block. Keep the existing tab indentation used in this file.) + +- [ ] **Step 3: Add the `schema/v3` typesVersions entry** + +In `packages/stack/package.json`, in the `typesVersions["*"]` object, add immediately after the existing `"schema"` entry: + +```json + "schema/v3": [ + "./dist/schema/v3/index.d.ts" + ], +``` + +- [ ] **Step 4: Build and verify the export resolves** + +Run: `pnpm run build` +Expected: build succeeds and emits `dist/schema/v3/index.js`, `dist/schema/v3/index.cjs`, `dist/schema/v3/index.d.ts`, `dist/schema/v3/index.d.cts`. + +Then verify the published export name resolves in both module systems (run from `packages/stack/`): + +```bash +node -e "const m = require('@cipherstash/stack/schema/v3'); if (typeof m.encryptedTextSearchColumn !== 'function') { throw new Error('CJS export missing'); } console.log('cjs ok')" +node --input-type=module -e "import('@cipherstash/stack/schema/v3').then(m => { if (typeof m.encryptedTextSearchColumn !== 'function') throw new Error('ESM export missing'); console.log('esm ok'); })" +``` + +Expected: prints `cjs ok` then `esm ok`. + +- [ ] **Step 5: Run the CJS-consumer regression test** + +The existing `__tests__/cjs-require.test.ts` auto-discovers every `dist/**/*.cjs` entry, so it now also exercises `dist/schema/v3/index.cjs` (no edit needed). + +Run: `pnpm exec vitest run __tests__/cjs-require.test.ts` +Expected: PASS — including the discovered `dist/schema/v3/index.cjs` entry (loads in a real Node CJS process, no externalized ESM-only `require`). + +- [ ] **Step 6: Commit** + +```bash +git add packages/stack/tsup.config.ts packages/stack/package.json +git commit -m "feat(stack): wire @cipherstash/stack/schema/v3 export subpath" +``` + +--- + +### Task 4: Type-level inference tests + CI enforcement + +**Files:** +- Create: `packages/stack/__tests__/schema-v3.test-d.ts` +- Create: `packages/stack/tsconfig.typecheck.json` (Step 4) +- Modify: `packages/stack/vitest.config.ts` (add a scoped `typecheck` block — Step 4) +- Modify: `packages/stack/package.json` (add a `test:types` script — Step 4) +- Modify: `.github/workflows/tests.yml` (run the scoped type tests in CI — Step 4) + +> Note: the v3 client-integration acceptance type-tests (`Encryption({ schemas: [v3users] })`, `client.encrypt`/`decrypt`/`encryptQuery` with v3 builders) are added in **Task 5**, which also appends to this same `schema-v3.test-d.ts`. They are enforced by the same CI wiring set up here. + +**Interfaces:** +- Consumes: `encryptedTable`, `encryptedTextSearchColumn`, `type EncryptedTextSearchColumn`, `type InferEncrypted`, `type InferPlaintext` from `@/schema/v3`; `type Encrypted` from `@/types`; `encryptedColumn` from `@/schema` (v2, for the negative `@ts-expect-error` rejection test). + +- [ ] **Step 1: Write type-level regression tests** + +These are regression/guard tests, expected to type-check green on first run (Tasks 1-2 already define the types they assert). Create `packages/stack/__tests__/schema-v3.test-d.ts`: + +```ts +import { describe, expectTypeOf, it } from 'vitest' +// v2 column builder — used only to prove the v3 table type rejects it. +import { encryptedColumn } from '@/schema' +import type { + EncryptedTextSearchColumn, + InferEncrypted, + InferPlaintext, +} from '@/schema/v3' +import { encryptedTable, encryptedTextSearchColumn } from '@/schema/v3' +import type { Encrypted } from '@/types' + +describe('eql_v3 schema type inference', () => { + it('encryptedTextSearchColumn returns an EncryptedTextSearchColumn', () => { + const col = encryptedTextSearchColumn('email') + expectTypeOf(col).toEqualTypeOf() + }) + + it('encryptedTable exposes column builders as typed properties', () => { + const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), + }) + expectTypeOf(users.email).toEqualTypeOf() + expectTypeOf(users.tableName).toBeString() + }) + + it('rejects a v2 EncryptedColumn in a v3 table (nominal private-field mismatch)', () => { + encryptedTable('users', { + // @ts-expect-error - a v2 EncryptedColumn is not an EncryptedTextSearchColumn + email: encryptedColumn('email'), + }) + }) + + it('InferPlaintext maps each column to string', () => { + const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), + name: encryptedTextSearchColumn('name'), + }) + type Plaintext = InferPlaintext + expectTypeOf().toEqualTypeOf<{ email: string; name: string }>() + }) + + it('InferEncrypted maps each column to Encrypted', () => { + const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), + }) + type Enc = InferEncrypted<typeof users> + expectTypeOf<Enc>().toEqualTypeOf<{ email: Encrypted }>() + }) +}) +``` + +- [ ] **Step 2: Create the SCOPED typecheck config + `test:types` script (BEFORE any typecheck run)** + +`.test-d.ts` files run ONLY in Vitest typecheck mode, and today nothing runs typecheck in CI (`package.json` `test` = `vitest run`; `tests.yml` runs `pnpm run test`). So neither this `schema-v3.test-d.ts` nor the pre-existing `types.test-d.ts` is enforced — a wrong inferred shape would NOT fail the build. + +**Verified finding (do not skip):** `tsconfig.json` has NO `include`, so a naive package-wide `vitest --typecheck` checks every file and surfaces **124 pre-existing "Unhandled Source Error"s** unrelated to v3 — `src/wasm-inline.ts` cannot resolve `@cipherstash/auth/wasm-inline` / `@cipherstash/protect-ffi/wasm-inline` type decls, plus a type mismatch at `__tests__/wasm-inline-normalize.test.ts:69`. (The `*.test-d.ts` assertions themselves pass.) So we set up the SCOPED config FIRST, so the very first typecheck a worker runs is already narrowed and green. Verified `@/encryption` does not import `wasm-inline.ts`, so a program rooted at the `*.test-d.ts` files does not reach the broken modules. + +a) Create `packages/stack/tsconfig.typecheck.json` — narrow roots so tsc only pulls the type-test files and what they actually import: + +```json +{ + "extends": "./tsconfig.json", + "include": ["__tests__/**/*.test-d.ts"] +} +``` + +b) Add a scoped `typecheck` block to `packages/stack/vitest.config.ts`: + +```ts +import { resolve } from 'node:path' +import { defineConfig } from 'vitest/config' + +export default defineConfig({ + resolve: { + alias: { + '@/': resolve(__dirname, './src') + '/', + }, + }, + test: { + typecheck: { + // Scoped tsconfig keeps the 124 pre-existing wasm-inline typecheck errors + // out of scope (tracked as a follow-up). Run via the `test:types` script + // with `--typecheck.only` so the runtime suites do NOT also execute. + tsconfig: './tsconfig.typecheck.json', + include: ['__tests__/**/*.test-d.ts'], + }, + }, +}) +``` + +c) Add a `test:types` script to `packages/stack/package.json`. Use `--typecheck.only` (Vitest **3.2.4**, confirmed in the repo, supports it) so ONLY the type tests run — `--typecheck` alone would ALSO run the runtime suites (including the credential/network-sensitive ones): + +```json + "test:types": "vitest --run --typecheck.only", +``` + +- [ ] **Step 3: Run the scoped type tests to verify they pass** + +Run: `pnpm run test:types` +Expected: PASS — `schema-v3.test-d.ts` type-checks (and the existing `types.test-d.ts` does too); ZERO errors; no runtime suites executed. (If `@/schema/v3` types were missing or `InferPlaintext`/`InferEncrypted` produced the wrong shape, `toEqualTypeOf` would surface a type error here. Tasks 1-2 already define these, so it type-checks green on first run.) + +> **STOP-gate:** if this scoped run still reports the `wasm-inline` errors (e.g. a type-test transitively imports a broken module), narrow `tsconfig.typecheck.json` further (add an `exclude` for `src/wasm-inline.ts` / `__tests__/wasm-inline-normalize.test.ts`) until the run is clean BEFORE wiring CI. Do not wire a red command into CI. + +- [ ] **Step 4: Run the full v3 runtime suite as a guard** + +Run: `pnpm exec vitest run __tests__/schema-v3.test.ts` +Expected: PASS (all runtime tests still green — no regression from the type-test file). + +- [ ] **Step 5: Wire the scoped type tests into CI** + +In `.github/workflows/tests.yml`, add a step in the `run-tests` job (after `Install dependencies`): + +```yaml + - name: Type tests (stack) + run: pnpm --filter @cipherstash/stack run test:types +``` + +> **Flagged follow-up (NOT fixed here):** the 124 pre-existing package-wide typecheck errors (missing `@cipherstash/{auth,protect-ffi}/wasm-inline` type declarations + `wasm-inline-normalize.test.ts:69`) are a separate cleanup. Enabling typecheck repo-wide / unscoped should be a dedicated follow-up after those are resolved. + +- [ ] **Step 6: Commit** + +```bash +git add packages/stack/__tests__/schema-v3.test-d.ts packages/stack/tsconfig.typecheck.json packages/stack/vitest.config.ts packages/stack/package.json .github/workflows/tests.yml +git commit -m "test(stack): type-level tests for eql_v3 schema DSL + scoped CI typecheck" +``` + +--- + +### Task 5: Widen the public client types to a structural contract (Option A — v3 works with the client) + +**Goal:** make the v3 builders first-class with the client API (`Encryption`, `encrypt`, `decrypt`, `encryptQuery`) by widening the blocking public types to a structural contract that BOTH v2 and v3 builders satisfy. Runtime is untouched (verified structural — no `instanceof` on the encrypt/decrypt/query path). + +**Decision — v3 keeps its OWN `EncryptedTable` class** (not reuse v2's): v3 needs a different column constraint (`EncryptedV3TableColumn`) and a simpler `build()` (no nested-field / ste_vec rewriting). v2 and v3 classes are nominally distinct (private fields) but BOTH structurally satisfy `BuildableColumn` / `BuildableTable`, which is exactly what a single widened type can accept. Reusing v2's class would not help anyway — v3 columns don't satisfy v2's `EncryptedTableColumn` generic constraint. + +**Verified structural members the client actually touches** (so the contract is minimal and correct): +- Column: `getName(): string` (`operations/encrypt.ts:53` etc.), `build(): ColumnSchema` (`helpers/infer-index-type.ts:11,58`). +- Table: `tableName: string` (`operations/encrypt.ts:52` etc.), `build(): { tableName; columns }` (`helpers/model-helpers.ts:268,566`; dynamodb ops; and `buildEncryptConfig(...schemas)` → `tb.build()` at `encryption/index.ts:674`). + +**Files:** +- Modify: `packages/stack/src/types.ts` — define `BuildableColumn` / `BuildableTable`; widen `EncryptionClientConfig.schemas`, `EncryptOptions`, `SearchTerm`, `QueryTermBase`. +- Modify: `packages/stack/src/schema/index.ts` — widen `buildEncryptConfig`'s parameter type ONLY (backward-compatible; the file already does `import type { Encrypted } from '@/types'`, so referencing `BuildableTable` from `@/types` adds no new module cycle). +- Modify: `packages/stack/src/encryption/operations/encrypt.ts` — internal consumer of the widened `EncryptOptions` (Step 3b). +- Modify: `packages/stack/src/encryption/operations/bulk-encrypt.ts` — internal consumer of the widened `EncryptOptions` (Step 3b). +- Modify: `packages/stack/src/encryption/helpers/infer-index-type.ts` — internal consumer of the widened query-term `column` (Step 3b). +- Test: append a `describe` block to `packages/stack/__tests__/schema-v3.test-d.ts`. + +> **Internal-consumer note (verified):** widening the public aliases is NOT enough on its own — three internal files store/accept those values in narrow v2 types and would fail typecheck. They are widened in Step 3b. Verified NOT needing changes (do not over-widen): the `EncryptionClient` class (stores only `client` + `encryptConfig`, passes `opts` straight through); `operations/encrypt-query.ts` / `batch-encrypt-query.ts` (store the public widened types directly, no narrow re-declaration); and the entire MODEL path (`encrypt-model.ts`, `bulk-encrypt-models.ts`, `model-helpers.ts`), which intentionally stays narrow because the generic model methods are NOT widened in this increment. + +**Interfaces (define in `src/types.ts`, alongside the other public client types):** + +```ts +import type { + ColumnSchema, + EncryptedColumn, + // ...existing imports (EncryptedColumn already imported; EncryptedField, EncryptedTable, EncryptedTableColumn) +} from '@/schema' + +/** Structural contract for a column builder the client can consume for STORAGE + * (`encrypt`). Satisfied by v2 `EncryptedColumn` / `EncryptedField` AND v3 + * `EncryptedTextSearchColumn` — fields ARE encryptable, so this stays wide. */ +export interface BuildableColumn { + getName(): string + build(): ColumnSchema +} + +/** Structural contract for a column the client can consume for QUERIES + * (`encryptQuery` / search terms). Narrower than `BuildableColumn`: it must + * EXCLUDE non-queryable `EncryptedField` (a field has no indexes). A v2 + * `EncryptedColumn` qualifies via the nominal arm; a v3 queryable concrete + * type qualifies via the `getEqlType()` structural arm; `EncryptedField` (no + * `getEqlType`, not an `EncryptedColumn`) is rejected. */ +export type BuildableQueryColumn = + | EncryptedColumn + | (BuildableColumn & { getEqlType(): string }) + +/** Structural contract for a table builder the client can consume. Satisfied by + * v2 and v3 `EncryptedTable` alike. */ +export interface BuildableTable { + tableName: string + build(): { tableName: string; columns: Record<string, ColumnSchema> } +} +``` + +- [ ] **Step 1: Write the failing client-integration acceptance tests** + +Append to `packages/stack/__tests__/schema-v3.test-d.ts`. First extend its imports — `import type { Encrypted } from '@/types'` and `encryptedColumn` from `@/schema` are ALREADY present from Task 4, so add ONLY the genuinely new symbols: + +```ts +// NEW imports for Task 5 (Encrypted + encryptedColumn already imported in Task 4): +import { Encryption, EncryptionClient } from '@/encryption' +// extend the existing `import { encryptedColumn } from '@/schema'` to also bring in: +import { + encryptedColumn, + encryptedField, + encryptedTable as v2EncryptedTable, +} from '@/schema' +``` + +Then append: + +```ts +describe('eql_v3 client integration (type-level acceptance)', () => { + const v3users = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), + }) + + it('Encryption accepts a v3 schema', () => { + expectTypeOf(Encryption).toBeCallableWith({ schemas: [v3users] }) + }) + + it('encrypt accepts a v3 table + column', () => { + const client = {} as EncryptionClient + expectTypeOf(client.encrypt).toBeCallableWith('alice@example.com', { + table: v3users, + column: v3users.email, + }) + }) + + it('encryptQuery accepts a v3 table + column', () => { + const client = {} as EncryptionClient + expectTypeOf(client.encryptQuery).toBeCallableWith('alice@example.com', { + table: v3users, + column: v3users.email, + }) + }) + + it('decrypt accepts an Encrypted value (round-trip target type; schema-independent)', () => { + const client = {} as EncryptionClient + expectTypeOf(client.decrypt).toBeCallableWith({} as Encrypted) + }) + + it('BACKWARD COMPAT: v2 tables/columns still satisfy the widened types', () => { + const v2users = v2EncryptedTable('users', { + email: encryptedColumn('email').equality(), + }) + expectTypeOf(Encryption).toBeCallableWith({ schemas: [v2users] }) + const client = {} as EncryptionClient + expectTypeOf(client.encrypt).toBeCallableWith('alice@example.com', { + table: v2users, + column: v2users.email, + }) + // a v2 EncryptedColumn is STILL queryable (nominal arm of BuildableQueryColumn) + expectTypeOf(client.encryptQuery).toBeCallableWith('alice@example.com', { + table: v2users, + column: v2users.email, + }) + }) + + it('a non-queryable v2 EncryptedField is encryptable but NOT queryable', () => { + const v2usersWithField = v2EncryptedTable('users', { + profile: { email: encryptedField('email') }, + }) + const client = {} as EncryptionClient + + // POSITIVE: a field IS encryptable (storage path = BuildableColumn) + expectTypeOf(client.encrypt).toBeCallableWith('alice@example.com', { + table: v2usersWithField, + column: v2usersWithField.profile.email, + }) + + // NEGATIVE: a field is NOT queryable. The query path uses + // BuildableQueryColumn, which excludes EncryptedField (no indexes). If the + // query path were instead widened to BuildableColumn (the rejected + // Batch-2/3 design), this call would compile and only fail at runtime with + // "no indexes configured" — so this test guards against that re-widening. + // + // The mismatch is a DEEP object-literal property error, so tsc reports it on + // the `column:` line — the `@ts-expect-error` MUST sit directly above that + // line (not above the call), or you get TS2578 "unused directive" + the real + // error leaking. (Mirror of Task 4's v2-column-rejected test placement.) + client.encryptQuery('alice@example.com', { + table: v2usersWithField, + // @ts-expect-error - EncryptedField is not assignable to BuildableQueryColumn + column: v2usersWithField.profile.email, + }) + }) +}) +``` + +- [ ] **Step 2: Run the type tests to verify they fail** + +Run: `pnpm run test:types` (script added in Task 4) +Expected: FAIL — the v3 `Encryption` / `encrypt` / `encryptQuery` assertions error because `EncryptedTextSearchColumn` / v3 `EncryptedTable` are not assignable to the still-nominal pre-Task-5 v2 types. These clear after Step 3. + +(The v2 backward-compat `encrypt`/`encryptQuery` assertions and `decrypt` already pass. The field tests also already pass: pre-Task-5 `QueryTermBase.column` is the original nominal `EncryptedColumn`, so the `@ts-expect-error` on querying a field is already a valid suppression — those tests stay green through Step 3, guarding against any future re-widening of the query path to `BuildableColumn`.) + +- [ ] **Step 3a: Define the structural contract and widen the public types** + +In `packages/stack/src/types.ts`: +1. Add `ColumnSchema` to the existing `@/schema` type import (`EncryptedColumn` is already imported there). +2. Add the `BuildableColumn` / `BuildableQueryColumn` / `BuildableTable` definitions (above). +3. Widen the blocking surfaces. Note the **storage vs query split**: `EncryptOptions` (encrypt) accepts `BuildableColumn` (columns AND fields), while `SearchTerm` / `QueryTermBase` (encryptQuery) accept the narrower `BuildableQueryColumn` so a non-queryable field is rejected at the type layer: + +```ts +export type EncryptionClientConfig = { + schemas: AtLeastOneCsTable<BuildableTable> + config?: ClientConfig +} + +export type EncryptOptions = { + column: BuildableColumn // storage: fields are encryptable, so stays wide + table: BuildableTable +} + +export type SearchTerm = { + value: JsPlaintext + column: BuildableQueryColumn // query: excludes non-queryable EncryptedField + table: BuildableTable + returnType?: EncryptedReturnType +} + +export type QueryTermBase = { + column: BuildableQueryColumn // query: excludes non-queryable EncryptedField + table: BuildableTable + queryType?: QueryTypeName + returnType?: EncryptedReturnType +} +``` + +In `packages/stack/src/schema/index.ts`, widen `buildEncryptConfig`'s parameter (the ONLY permitted edit to the v2 module — pure widening, no behavior change): + +```ts +import type { BuildableTable, Encrypted } from '@/types' + +export function buildEncryptConfig( + ...protectTables: Array<BuildableTable> +): EncryptConfig { + // body unchanged — already only calls tb.build() +} +``` + +> **Do NOT touch** the generic schema-aware model methods `encryptModel<S extends EncryptedTableColumn>` / `bulkEncryptModels` (`encryption/index.ts:394,489`) or `EncryptedFromSchema` / `InferPlaintext` / `EncryptedFields`. They must keep inferring `S` from `EncryptedTable<S>` so v2 field-level inference is preserved. v3 support for the model methods is a future increment (v3 columns don't satisfy `EncryptedTableColumn`). The `EncryptedTable<T> & T` accessor and v2 inference must be re-verified green (Step 4). +> +> **Fallback (if the team forbids ANY v2-module edit):** instead of widening `buildEncryptConfig`, leave it as-is and change `Encryption()` (`encryption/index.ts`) to assemble the config inline from the structural `schemas` (`for (const tb of schemas) { const d = tb.build(); config.tables[d.tableName] = d.columns }`). This keeps `src/schema/index.ts` pristine at the cost of ~6 duplicated lines in the client. + +- [ ] **Step 3b: Widen the internal consumers the public change forces** + +After Step 3a, the package will NOT typecheck until the internal consumers that store/accept the widened values are widened too. All three only call `.getName()`, `.tableName`, and `column.build().indexes` — so `BuildableColumn` / `BuildableTable` are sufficient (no richer contract). Widen exactly these, and nothing in the model path: + +1. **`src/encryption/operations/encrypt.ts`** — `EncryptOperation`: + - field `private column: EncryptedColumn | EncryptedField` (:27) → `private column: BuildableColumn` + - field `private table: EncryptedTable<EncryptedTableColumn>` (:28) → `private table: BuildableTable` + - `getOperation()` return type's `column` / `table` (:112-113) → `BuildableColumn` / `BuildableTable` + - imports: add `BuildableColumn, BuildableTable` to the `@/types` import; drop the now-unused `EncryptedColumn, EncryptedField, EncryptedTable, EncryptedTableColumn` from the `@/schema` import (if nothing else uses them). + - The constructor already takes `opts: EncryptOptions` (widened) — no signature change; only the field/return types. + +2. **`src/encryption/operations/bulk-encrypt.ts`** — `BulkEncryptOperation`: + - module fn `createEncryptPayloads(column: EncryptedColumn | EncryptedField, table: EncryptedTable<EncryptedTableColumn>, ...)` (:28-29) → `column: BuildableColumn, table: BuildableTable` + - fields `private column` (:66) / `private table` (:67) → `BuildableColumn` / `BuildableTable` + - **`BulkEncryptOperation.getOperation()` return type (:141-142)** — REQUIRED widen-site: it re-exposes `column: EncryptedColumn | EncryptedField` (:141) and `table: EncryptedTable<EncryptedTableColumn>` (:142) → `BuildableColumn` / `BuildableTable`. (This return value is destructured and consumed by `BulkEncryptOperationWithLockContext.execute()` at :168, which only uses `.getName()` / `.tableName`.) Do NOT miss this — leaving it narrow keeps `bulk-encrypt.ts` red. (Note: this is `getOperation()`'s return type on `BulkEncryptOperation`, NOT a member of the `*WithLockContext` class.) + - same import swap (`@/types` gains `BuildableColumn, BuildableTable`; drop unused `@/schema` narrow types). + +3. **`src/encryption/helpers/infer-index-type.ts`** — index inference (QUERY path only — verified reached solely via `resolveIndexType` from `encrypt-query.ts:72,165` and `batch-encrypt-query.ts:51`, NOT from the storage path): + - `inferIndexType(column: EncryptedColumn)` (:10), `validateIndexType(column: EncryptedColumn, ...)` (:55), `resolveIndexType(column: EncryptedColumn, ...)` (:87) → `column: BuildableQueryColumn` in all three (NOT `BuildableColumn` — these run only for queries, so they should reject non-queryable fields too). + - import: replace `import type { EncryptedColumn } from '@/schema'` with `import type { BuildableQueryColumn } from '@/types'`. + - Bodies are unchanged: they read `column.build().indexes` and `column.getName()`, both available on `BuildableQueryColumn` (its `EncryptedColumn` arm and its `BuildableColumn & …` arm each provide `getName()` + `build()`). + +> **Do NOT widen the model path.** `encrypt-model.ts`, `bulk-encrypt-models.ts`, and `model-helpers.ts` keep `EncryptedTable<EncryptedTableColumn>` / `EncryptedTable<S>` — they are fed by the generic `encryptModel<S extends EncryptedTableColumn>` methods which are intentionally left narrow (preserves v2 inference; v3 model support is a later increment). Widening them would over-reach and could disturb inference. +> +> **WASM-inline boundary (documented, not fixed here).** `src/wasm-inline.ts:314-320` has `getColumnName(col)` doing `if (col instanceof EncryptedColumn || col instanceof EncryptedField) … else throw`. After widening `EncryptOptions['column']` to `BuildableColumn` this still type-checks (an `instanceof` guard narrows a wider type fine) and `wasm-inline.ts` is outside the scoped typecheck graph (`@/encryption` does not import it; the `test:types` tsconfig roots only the `*.test-d.ts` files), so it does NOT turn the package red — but a v3 column routed through the WASM-inline entry would hit the `else throw` at RUNTIME. The batch-2 "no `instanceof`" finding was explicitly scoped to `operations/*.ts`; the WASM-inline entry does not yet accept v3 columns, which is a deferred, documented boundary (not a latent surprise). + +- [ ] **Step 4: Run the full suite to verify pass + no regression** + +```bash +pnpm run test:types # v3 acceptance + v2 backward-compat + existing types.test-d.ts all green +pnpm exec vitest run # all runtime tests still pass (encryptModel inference unaffected) +``` + +Expected: all green. In particular `__tests__/types.test-d.ts` (v2 inference, `EncryptedFromSchema`, `encryptModel` schema-aware return types) must still pass — proving the widening did not narrow or break v2. + +- [ ] **Step 5: Commit** + +```bash +git add packages/stack/src/types.ts packages/stack/src/schema/index.ts \ + packages/stack/src/encryption/operations/encrypt.ts \ + packages/stack/src/encryption/operations/bulk-encrypt.ts \ + packages/stack/src/encryption/helpers/infer-index-type.ts \ + packages/stack/__tests__/schema-v3.test-d.ts +git commit -m "feat(stack): widen public client types so v3 builders work with the client" +``` + +--- + +### Task 6: Changeset + +**Files:** +- Create: `.changeset/eql-v3-text-search.md` + +**Interfaces:** none (release metadata only). The repo uses Changesets (`.changeset/config.json`); frontmatter keys are package `name`s. `packages/stack/package.json` name is `@cipherstash/stack`. + +- [ ] **Step 1: Create the changeset** + +Create `.changeset/eql-v3-text-search.md` (minor — additive `./schema/v3` subpath + exports, plus backward-compatible public-type widening; no breaking changes): + +```md +--- +"@cipherstash/stack": minor +--- + +Add the EQL v3 `text_search` authoring DSL on a new `@cipherstash/stack/schema/v3` +subpath (`encryptedTextSearchColumn`, v3 `encryptedTable` / `buildEncryptConfig`). +The v3 builders emit the existing `EncryptConfig` shape, so encryption, payloads, +and query paths are unchanged at runtime. + +Also widens the public client types (`EncryptionClientConfig.schemas`, +`EncryptOptions`, `SearchTerm`/`EncryptQueryOptions`) to a structural contract so +both v2 and v3 builders are accepted by `Encryption` / `encrypt` / `decrypt` / +`encryptQuery`. This is a backward-compatible widening — existing v2 usage is +unaffected. +``` + +- [ ] **Step 2: Verify the changeset is valid** + +Run: `pnpm exec changeset status` (from the repo root) +Expected: lists a pending `minor` bump for `@cipherstash/stack`, no errors. (If `changeset status` is unavailable in this environment, confirm the frontmatter key exactly matches the package `name` and the bump keyword is one of `major`/`minor`/`patch`.) + +- [ ] **Step 3: Commit** + +```bash +git add .changeset/eql-v3-text-search.md +git commit -m "chore(stack): changeset for eql_v3 text_search DSL (minor)" +``` + +--- + +## Self-Review + +**Spec coverage:** +- Public API (`encryptedTextSearchColumn`, v3 `encryptedTable`, v3 `buildEncryptConfig`) → Tasks 1-2. +- `.freeTextSearch(opts?)` as tuning-only with per-key replace merge → Task 1, Steps 1 & 3 (override + tuning-only tests). +- Pinned `build()` output (`cast_as: 'string'` + three indexes, defaults) → Task 1, default-config test. +- Load-bearing v2/v3 equivalence assertion → Task 1, "LOAD-BEARING" test (imports v2 `encryptedColumn`). +- `'eql_v3.text_search'` via `getEqlType()` method (no property getter), absent from `build()` → Task 1, getEqlType + absence tests. +- `buildEncryptConfig` → valid `EncryptConfig` (`v: 1`) passing `encryptConfigSchema.parse` → Task 2. +- `InferPlaintext` / `InferEncrypted` → Task 4 (type) + Task 2 (definition). +- New `@cipherstash/stack/schema/v3` subpath (exports + tsup) → Task 3. +- No shared mutable state (per-instance defaults + cloned `build()`) → Task 1 (`defaultMatchOpts()` factory + independent-mutation test). +- **Client integration (Option A):** widen public types AND the internal consumers they force so v3 builders work with `Encryption` / `encrypt` / `decrypt` / `encryptQuery`; storage path (`encrypt`, `operations/encrypt.ts`, `operations/bulk-encrypt.ts`) uses `BuildableColumn` (accepts fields), query path (`encryptQuery`, `helpers/infer-index-type.ts`) uses the narrower `BuildableQueryColumn` (rejects non-queryable fields); model path left narrow; v2 backward-compat preserved → Task 5 (Steps 3a + 3b). +- Type tests enforced in CI (scoped typecheck, `--typecheck.only`) → Task 4, Steps 2-3 (scoped config + script) and Step 5 (CI wiring). +- Changeset (minor) for the public-surface change → Task 6. +- v2 module: runtime + existing exported shapes untouched; ONLY a backward-compatible `buildEncryptConfig` param widening (Task 5) — see Global Constraints. +- Non-goals (v3 in the generic model methods, DDL, transition tooling, query dialect, other concrete types, nested fields) → not implemented (correctly out of scope). + +**Placeholder scan:** No TBD/TODO/"handle edge cases" present; every code step contains complete, runnable code. + +**Type consistency:** `EncryptedTextSearchColumn`, `encryptedTextSearchColumn`, `EncryptedTable`, `encryptedTable`, `buildEncryptConfig`, `EncryptedV3TableColumn`, `InferPlaintext`, `InferEncrypted`, `TEXT_SEARCH_EQL_TYPE`, the `defaultMatchOpts()` factory, `getEqlType()` (method only — no property getter; also the query-path discriminator in `BuildableQueryColumn`), and the structural `BuildableColumn` / `BuildableQueryColumn` / `BuildableTable` contract (Task 5) are used identically across tasks and tests. `build()` returns `ColumnSchema`; `EncryptedTable.build()` returns `{ tableName, columns: Record<string, ColumnSchema> }`, matching both `buildEncryptConfig`'s consumption and the `BuildableTable` contract. + +--- + +## Execution Handoff + +Plan complete and saved to `docs/superpowers/plans/2026-06-30-eql-v3-text-search-schema-plan.md`. Two execution options: + +1. **Subagent-Driven (recommended)** — dispatch a fresh subagent per task, review between tasks, fast iteration. +2. **Inline Execution** — execute tasks in this session using executing-plans, batch execution with checkpoints. + +Which approach? +</content> +</invoke> diff --git a/docs/superpowers/plans/2026-07-01-eql-v3-typed-schema.md b/docs/superpowers/plans/2026-07-01-eql-v3-typed-schema.md new file mode 100644 index 00000000..88ec2f5a --- /dev/null +++ b/docs/superpowers/plans/2026-07-01-eql-v3-typed-schema.md @@ -0,0 +1,1547 @@ +# EQL v3 Typed Schema Implementation Plan + +> **Superseded (re-baseline, 2026-07-05):** written against the +> pre-`eql-3.0.0-alpha.2` EQL v3 surface — old domain names (`int4`, +> `timestamptz`, …, since renamed to SQL-standard `integer`, `timestamp`, …), +> `v: 2` envelope pins, and no `eql_v3_internal` schema. Retained as a +> historical design record; the shipped surface is the re-baselined one. + +> **Superseded (2026-07-03):** this plan added per-domain `encrypted<Domain>Column` +> builders on `@cipherstash/stack/schema/v3`. Those builders are now the `types` +> namespace (`types.TextEq` / `types.Int4Ord` / …) on `@cipherstash/stack/eql/v3`. +> Retained as a historical execution record — do not re-run against the current tree. + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Expand `@cipherstash/stack/schema/v3` from the current `text_search` slice to all generated EQL v3 SQL domains with domain-precise builders, explicit query capability metadata, and structurally widened client/model support while preserving v2 behavior. + +**Architecture:** Keep v3 isolated under `packages/stack/src/schema/v3/index.ts` and the `@cipherstash/stack/schema/v3` export. Implement one v3 column class/builder per EQL v3 domain using a shared internal column base parameterized by the full literal domain definition (`eqlType`, `castAs`, capabilities), not by capabilities alone. Client query typing should accept v3 columns only when they expose capability metadata and `isQueryable(): true`; storage-only v3 columns remain encryptable but not queryable. + +**Tech Stack:** TypeScript, Vitest runtime tests, Vitest type tests, tsup package build, `@cipherstash/protect-ffi`, existing `ColumnSchema`/`EncryptConfig` v1 config shape. + +--- + +## File Structure Map + +**Modify:** +- `packages/stack/src/schema/v3/index.ts` + - Owns all v3 builders, domain metadata, table builder, `buildEncryptConfig`, and v3 `InferPlaintext` / `InferEncrypted`. +- `packages/stack/src/types.ts` + - Tightens `BuildableQueryColumn`; widens model schema typing from v2-only columns to structural buildable table columns while preserving literal schema keys through each table's `_columnType` brand. +- `packages/stack/src/encryption/index.ts` + - Updates `encryptModel` and `bulkEncryptModels` generics and table parameter types to accept v3 tables. +- `packages/stack/src/encryption/helpers/model-helpers.ts` + - Replaces v2 `EncryptedTable<EncryptedTableColumn>` annotations with structural `BuildableTable`. +- `packages/stack/src/encryption/operations/encrypt-model.ts` + - Replaces v2 table annotations with `BuildableTable`. +- `packages/stack/src/encryption/operations/bulk-encrypt-models.ts` + - Replaces v2 table annotations with `BuildableTable`. +- `packages/stack/src/wasm-inline.ts` + - Widens WASM schema config type to structural buildable tables if needed; keeps structural `getColumnName`. +- `packages/stack/vitest.config.ts` + - Fixes or isolates `@cipherstash/protect-ffi/wasm-inline` import resolution for `wasm-inline-column-name.test.ts`. +- `packages/stack/package.json` + - Keep existing `./schema/v3` export and `db:eql-v3:install`; add no new subpath unless tests prove required. + +**Modify tests:** +- `packages/stack/__tests__/schema-v3.test.ts` + - Runtime builder/config/capability tests for all v3 domains. +- `packages/stack/__tests__/schema-v3.test-d.ts` + - Type-level tests for all builders, queryability, inferred plaintext/encrypted model shapes, and v2 compatibility. +- `packages/stack/__tests__/schema-v3-client.test.ts` + - Live env-gated client tests expanded to representative storage-only/equality/order/match/search columns. +- `packages/stack/__tests__/schema-v3-pg.test.ts` + - Keep guarded Postgres `text_search` coverage; add representative non-text EQL v3 domains when the SQL fixture supports them. +- `packages/stack/__tests__/wasm-inline-column-name.test.ts` + - Keep focused column-name test; update import style only if needed after Vitest resolution fix. + +**Create:** +- `.changeset/eql-v3-typed-schema.md` + - Public API addition for `@cipherstash/stack`. + +**Do not modify:** +- `packages/stack/src/schema/index.ts` + - v2 schema API remains stable. +- Payload contracts and Result shapes. +- Any code that logs plaintext. + +--- + +### Task 1: Baseline And Source-Of-Truth Snapshot + +**Files:** +- Read only: `packages/stack/src/schema/v3/index.ts` +- Read only: `<eql-v3-worktree>/crates/eql-bindings/src/v3/inventory.rs` +- Read only: `<eql-v3-worktree>/crates/eql-bindings/schema/v3/*.json` + +- [ ] **Step 1: Confirm branch and dirty state** + +Run: + +```bash +git status --short --branch +``` + +Expected: + +```text +## feat/eql-v3-text-search-schema...origin/feat/eql-v3-text-search-schema +``` + +Also expect currently untracked v3 live-test/helper files and the `packages/stack/package.json` script change. Do not revert them. + +- [ ] **Step 2: Confirm complete v3 domain inventory** + +Run: + +```bash +sed -n '1,140p' <eql-v3-worktree>/crates/eql-bindings/src/v3/inventory.rs +``` + +Expected: inventory includes exactly these domain identifiers: + +```text +int4 int4_eq int4_ord_ore int4_ord +int2 int2_eq int2_ord_ore int2_ord +int8 int8_eq int8_ord_ore int8_ord +date date_eq date_ord_ore date_ord +timestamptz timestamptz_eq timestamptz_ord_ore timestamptz_ord +numeric numeric_eq numeric_ord_ore numeric_ord +text text_eq text_match text_ord_ore text_ord text_search +bool +float4 float4_eq float4_ord_ore float4_ord +float8 float8_eq float8_ord_ore float8_ord +``` + +- [ ] **Step 3: Confirm capability rule from JSON schemas** + +Run: + +```bash +rg '"required"' <eql-v3-worktree>/crates/eql-bindings/schema/v3 -n +``` + +Expected: +- Schemas with required `hm` support equality. +- Schemas with required `ob` support order/range. +- Schemas with required `bf` support free-text search. +- Those exposing only `v`, `i`, `c` are storage-only. + +--- + +### Task 2: Write Failing Runtime Tests For All v3 Builders + +**Files:** +- Modify: `packages/stack/__tests__/schema-v3.test.ts` + +- [ ] **Step 1: Add import coverage for every new builder and class** + +Replace the v3 import block with this full import list: + +```ts +import { + buildEncryptConfig, + EncryptedBoolColumn, + EncryptedDateColumn, + EncryptedDateEqColumn, + EncryptedDateOrdColumn, + EncryptedDateOrdOreColumn, + EncryptedFloat4Column, + EncryptedFloat4EqColumn, + EncryptedFloat4OrdColumn, + EncryptedFloat4OrdOreColumn, + EncryptedFloat8Column, + EncryptedFloat8EqColumn, + EncryptedFloat8OrdColumn, + EncryptedFloat8OrdOreColumn, + EncryptedInt2Column, + EncryptedInt2EqColumn, + EncryptedInt2OrdColumn, + EncryptedInt2OrdOreColumn, + EncryptedInt4Column, + EncryptedInt4EqColumn, + EncryptedInt4OrdColumn, + EncryptedInt4OrdOreColumn, + EncryptedInt8Column, + EncryptedInt8EqColumn, + EncryptedInt8OrdColumn, + EncryptedInt8OrdOreColumn, + EncryptedNumericColumn, + EncryptedNumericEqColumn, + EncryptedNumericOrdColumn, + EncryptedNumericOrdOreColumn, + EncryptedTable, + EncryptedTextColumn, + EncryptedTextEqColumn, + EncryptedTextMatchColumn, + EncryptedTextOrdColumn, + EncryptedTextOrdOreColumn, + EncryptedTextSearchColumn, + EncryptedTimestamptzColumn, + EncryptedTimestamptzEqColumn, + EncryptedTimestamptzOrdColumn, + EncryptedTimestamptzOrdOreColumn, + encryptedBoolColumn, + encryptedDateColumn, + encryptedDateEqColumn, + encryptedDateOrdColumn, + encryptedDateOrdOreColumn, + encryptedFloat4Column, + encryptedFloat4EqColumn, + encryptedFloat4OrdColumn, + encryptedFloat4OrdOreColumn, + encryptedFloat8Column, + encryptedFloat8EqColumn, + encryptedFloat8OrdColumn, + encryptedFloat8OrdOreColumn, + encryptedInt2Column, + encryptedInt2EqColumn, + encryptedInt2OrdColumn, + encryptedInt2OrdOreColumn, + encryptedInt4Column, + encryptedInt4EqColumn, + encryptedInt4OrdColumn, + encryptedInt4OrdOreColumn, + encryptedInt8Column, + encryptedInt8EqColumn, + encryptedInt8OrdColumn, + encryptedInt8OrdOreColumn, + encryptedNumericColumn, + encryptedNumericEqColumn, + encryptedNumericOrdColumn, + encryptedNumericOrdOreColumn, + encryptedTable, + encryptedTextColumn, + encryptedTextEqColumn, + encryptedTextMatchColumn, + encryptedTextOrdColumn, + encryptedTextOrdOreColumn, + encryptedTextSearchColumn, + encryptedTimestamptzColumn, + encryptedTimestamptzEqColumn, + encryptedTimestamptzOrdColumn, + encryptedTimestamptzOrdOreColumn, +} from '@/schema/v3' +``` + +- [ ] **Step 2: Add a complete table-driven domain test** + +Add this test near the top of `schema-v3.test.ts`: + +```ts +const domainCases = [ + ['eql_v3.int4', encryptedInt4Column, EncryptedInt4Column, 'number', {}, { equality: false, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.int4_eq', encryptedInt4EqColumn, EncryptedInt4EqColumn, 'number', { unique: { token_filters: [] } }, { equality: true, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.int4_ord_ore', encryptedInt4OrdOreColumn, EncryptedInt4OrdOreColumn, 'number', { ore: {} }, { equality: true, orderAndRange: true, freeTextSearch: false }], + ['eql_v3.int4_ord', encryptedInt4OrdColumn, EncryptedInt4OrdColumn, 'number', { ore: {} }, { equality: true, orderAndRange: true, freeTextSearch: false }], + ['eql_v3.int2', encryptedInt2Column, EncryptedInt2Column, 'number', {}, { equality: false, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.int2_eq', encryptedInt2EqColumn, EncryptedInt2EqColumn, 'number', { unique: { token_filters: [] } }, { equality: true, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.int2_ord_ore', encryptedInt2OrdOreColumn, EncryptedInt2OrdOreColumn, 'number', { ore: {} }, { equality: true, orderAndRange: true, freeTextSearch: false }], + ['eql_v3.int2_ord', encryptedInt2OrdColumn, EncryptedInt2OrdColumn, 'number', { ore: {} }, { equality: true, orderAndRange: true, freeTextSearch: false }], + ['eql_v3.int8', encryptedInt8Column, EncryptedInt8Column, 'bigint', {}, { equality: false, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.int8_eq', encryptedInt8EqColumn, EncryptedInt8EqColumn, 'bigint', { unique: { token_filters: [] } }, { equality: true, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.int8_ord_ore', encryptedInt8OrdOreColumn, EncryptedInt8OrdOreColumn, 'bigint', { ore: {} }, { equality: true, orderAndRange: true, freeTextSearch: false }], + ['eql_v3.int8_ord', encryptedInt8OrdColumn, EncryptedInt8OrdColumn, 'bigint', { ore: {} }, { equality: true, orderAndRange: true, freeTextSearch: false }], + ['eql_v3.date', encryptedDateColumn, EncryptedDateColumn, 'date', {}, { equality: false, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.date_eq', encryptedDateEqColumn, EncryptedDateEqColumn, 'date', { unique: { token_filters: [] } }, { equality: true, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.date_ord_ore', encryptedDateOrdOreColumn, EncryptedDateOrdOreColumn, 'date', { ore: {} }, { equality: true, orderAndRange: true, freeTextSearch: false }], + ['eql_v3.date_ord', encryptedDateOrdColumn, EncryptedDateOrdColumn, 'date', { ore: {} }, { equality: true, orderAndRange: true, freeTextSearch: false }], + ['eql_v3.timestamptz', encryptedTimestamptzColumn, EncryptedTimestamptzColumn, 'date', {}, { equality: false, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.timestamptz_eq', encryptedTimestamptzEqColumn, EncryptedTimestamptzEqColumn, 'date', { unique: { token_filters: [] } }, { equality: true, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.timestamptz_ord_ore', encryptedTimestamptzOrdOreColumn, EncryptedTimestamptzOrdOreColumn, 'date', { ore: {} }, { equality: true, orderAndRange: true, freeTextSearch: false }], + ['eql_v3.timestamptz_ord', encryptedTimestamptzOrdColumn, EncryptedTimestamptzOrdColumn, 'date', { ore: {} }, { equality: true, orderAndRange: true, freeTextSearch: false }], + ['eql_v3.numeric', encryptedNumericColumn, EncryptedNumericColumn, 'number', {}, { equality: false, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.numeric_eq', encryptedNumericEqColumn, EncryptedNumericEqColumn, 'number', { unique: { token_filters: [] } }, { equality: true, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.numeric_ord_ore', encryptedNumericOrdOreColumn, EncryptedNumericOrdOreColumn, 'number', { ore: {} }, { equality: true, orderAndRange: true, freeTextSearch: false }], + ['eql_v3.numeric_ord', encryptedNumericOrdColumn, EncryptedNumericOrdColumn, 'number', { ore: {} }, { equality: true, orderAndRange: true, freeTextSearch: false }], + ['eql_v3.text', encryptedTextColumn, EncryptedTextColumn, 'string', {}, { equality: false, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.text_eq', encryptedTextEqColumn, EncryptedTextEqColumn, 'string', { unique: { token_filters: [] } }, { equality: true, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.text_match', encryptedTextMatchColumn, EncryptedTextMatchColumn, 'string', { match: { tokenizer: { kind: 'ngram', token_length: 3 }, token_filters: [{ kind: 'downcase' }], k: 6, m: 2048, include_original: true } }, { equality: false, orderAndRange: false, freeTextSearch: true }], + ['eql_v3.text_ord_ore', encryptedTextOrdOreColumn, EncryptedTextOrdOreColumn, 'string', { ore: {} }, { equality: true, orderAndRange: true, freeTextSearch: false }], + ['eql_v3.text_ord', encryptedTextOrdColumn, EncryptedTextOrdColumn, 'string', { ore: {} }, { equality: true, orderAndRange: true, freeTextSearch: false }], + ['eql_v3.bool', encryptedBoolColumn, EncryptedBoolColumn, 'boolean', {}, { equality: false, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.float4', encryptedFloat4Column, EncryptedFloat4Column, 'number', {}, { equality: false, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.float4_eq', encryptedFloat4EqColumn, EncryptedFloat4EqColumn, 'number', { unique: { token_filters: [] } }, { equality: true, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.float4_ord_ore', encryptedFloat4OrdOreColumn, EncryptedFloat4OrdOreColumn, 'number', { ore: {} }, { equality: true, orderAndRange: true, freeTextSearch: false }], + ['eql_v3.float4_ord', encryptedFloat4OrdColumn, EncryptedFloat4OrdColumn, 'number', { ore: {} }, { equality: true, orderAndRange: true, freeTextSearch: false }], + ['eql_v3.float8', encryptedFloat8Column, EncryptedFloat8Column, 'number', {}, { equality: false, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.float8_eq', encryptedFloat8EqColumn, EncryptedFloat8EqColumn, 'number', { unique: { token_filters: [] } }, { equality: true, orderAndRange: false, freeTextSearch: false }], + ['eql_v3.float8_ord_ore', encryptedFloat8OrdOreColumn, EncryptedFloat8OrdOreColumn, 'number', { ore: {} }, { equality: true, orderAndRange: true, freeTextSearch: false }], + ['eql_v3.float8_ord', encryptedFloat8OrdColumn, EncryptedFloat8OrdColumn, 'number', { ore: {} }, { equality: true, orderAndRange: true, freeTextSearch: false }], +] as const + +describe('eql_v3 concrete domain columns', () => { + it.each(domainCases)('%s builder exposes name, config, type, and capabilities', (eqlType, factory, Klass, castAs, indexes, capabilities) => { + const col = factory('value') + expect(col).toBeInstanceOf(Klass) + expect(col.getName()).toBe('value') + expect(col.getEqlType()).toBe(eqlType) + expect(col.getQueryCapabilities()).toStrictEqual(capabilities) + expect(col.isQueryable()).toBe(Object.values(capabilities).some(Boolean)) + expect(col.build()).toStrictEqual({ cast_as: castAs, indexes }) + expect(col.build()).not.toHaveProperty('eqlType') + expect(col.build()).not.toHaveProperty('queryCapabilities') + }) +}) +``` + +- [ ] **Step 3: Keep and adapt existing `text_search` tests** + +Keep existing `text_search` tests, but add: + +```ts +expect(encryptedTextSearchColumn('email').getQueryCapabilities()).toStrictEqual({ + equality: true, + orderAndRange: true, + freeTextSearch: true, +}) +expect(encryptedTextSearchColumn('email').isQueryable()).toBe(true) +``` + +- [ ] **Step 4: Run runtime test and confirm failure** + +Run: + +```bash +pnpm --filter @cipherstash/stack vitest run __tests__/schema-v3.test.ts +``` + +Expected: FAIL with missing exports such as `encryptedInt4Column` and missing methods `getQueryCapabilities` / `isQueryable`. + +--- + +### Task 3: Implement v3 Domain Column Base And Builders + +**Files:** +- Modify: `packages/stack/src/schema/v3/index.ts` + +- [ ] **Step 1: Add shared capability and full domain-definition types** + +Add near the top of `schema/v3/index.ts`: + +```ts +export type QueryCapabilities = Readonly<{ + equality: boolean + orderAndRange: boolean + freeTextSearch: boolean +}> + +type PlaintextKind = 'string' | 'number' | 'bigint' | 'boolean' | 'date' + +type V3DomainDefinition = Readonly<{ + eqlType: `eql_v3.${string}` + castAs: PlaintextKind + capabilities: QueryCapabilities +}> + +type QueryableFlag<D extends V3DomainDefinition> = + D['capabilities'] extends { equality: false; orderAndRange: false; freeTextSearch: false } + ? false + : true + +const STORAGE_ONLY = { + equality: false, + orderAndRange: false, + freeTextSearch: false, +} as const + +const EQUALITY_ONLY = { + equality: true, + orderAndRange: false, + freeTextSearch: false, +} as const + +const ORDER_AND_RANGE = { + equality: true, + orderAndRange: true, + freeTextSearch: false, +} as const + +const MATCH_ONLY = { + equality: false, + orderAndRange: false, + freeTextSearch: true, +} as const + +const TEXT_SEARCH = { + equality: true, + orderAndRange: true, + freeTextSearch: true, +} as const + +const INT4 = { eqlType: 'eql_v3.int4', castAs: 'number', capabilities: STORAGE_ONLY } as const +const INT4_EQ = { eqlType: 'eql_v3.int4_eq', castAs: 'number', capabilities: EQUALITY_ONLY } as const +const INT4_ORD_ORE = { eqlType: 'eql_v3.int4_ord_ore', castAs: 'number', capabilities: ORDER_AND_RANGE } as const +const INT4_ORD = { eqlType: 'eql_v3.int4_ord', castAs: 'number', capabilities: ORDER_AND_RANGE } as const +``` + +Every concrete domain must get its own `as const` domain definition object. This is load-bearing: empty subclasses are not nominal in TypeScript, so the base class must carry literal `eqlType`/`castAs` data in its private definition field. Do not type columns as `EncryptedV3Column<typeof STORAGE_ONLY>`; that makes all storage-only domains mutually assignable and breaks plaintext inference. + +- [ ] **Step 2: Add config helpers** + +Add these helpers before column classes: + +```ts +function indexesForCapabilities(capabilities: QueryCapabilities): ColumnSchema['indexes'] { + const indexes: ColumnSchema['indexes'] = {} + + if (capabilities.equality && !capabilities.orderAndRange) { + indexes.unique = { token_filters: [] } + } + + if (capabilities.orderAndRange) { + indexes.ore = {} + } + + if (capabilities.freeTextSearch) { + const match = defaultMatchOpts() + indexes.match = { + ...match, + tokenizer: { ...match.tokenizer }, + token_filters: match.token_filters.map((f) => ({ ...f })), + } + } + + return indexes +} + +function isQueryableCapabilities(capabilities: QueryCapabilities): boolean { + return capabilities.equality || capabilities.orderAndRange || capabilities.freeTextSearch +} +``` + +Important: `orderAndRange` domains use `{ ore: {} }` only. Do not also emit `unique`; the EQL v3 `ob` key supports equality and range. + +- [ ] **Step 3: Add generic base class** + +Add: + +```ts +class EncryptedV3Column<D extends V3DomainDefinition> { + constructor( + private readonly columnName: string, + private readonly definition: D, + ) {} + + getName(): string { + return this.columnName + } + + getEqlType(): D['eqlType'] { + return this.definition.eqlType + } + + getQueryCapabilities(): D['capabilities'] { + return this.definition.capabilities + } + + isQueryable(): QueryableFlag<D> { + return isQueryableCapabilities(this.definition.capabilities) as QueryableFlag<D> + } + + build(): ColumnSchema { + return { + cast_as: this.definition.castAs, + indexes: indexesForCapabilities(this.definition.capabilities), + } + } +} +``` + +Because `definition` is a private base field whose type includes literal `eqlType` and `castAs`, `EncryptedBoolColumn` is no longer assignable to `EncryptedInt8Column` even if both are storage-only. + +- [ ] **Step 4: Keep text-search override semantics** + +Change `EncryptedTextSearchColumn` to extend the base but keep its existing `matchOpts`, `freeTextSearch(opts?)`, and deep-clone behavior. + +Expected final shape: + +```ts +const TEXT_SEARCH_DOMAIN = { + eqlType: TEXT_SEARCH_EQL_TYPE, + castAs: 'string', + capabilities: TEXT_SEARCH, +} as const + +export class EncryptedTextSearchColumn extends EncryptedV3Column<typeof TEXT_SEARCH_DOMAIN> { + private matchOpts: BuiltMatchIndexOpts + + constructor(columnName: string) { + super(columnName, TEXT_SEARCH_DOMAIN) + this.matchOpts = defaultMatchOpts() + } + + freeTextSearch(opts?: MatchIndexOpts): this { + const defaults = defaultMatchOpts() + this.matchOpts = { + tokenizer: opts?.tokenizer ?? defaults.tokenizer, + token_filters: opts?.token_filters ?? defaults.token_filters, + k: opts?.k ?? defaults.k, + m: opts?.m ?? defaults.m, + include_original: opts?.include_original ?? defaults.include_original, + } + return this + } + + override build(): ColumnSchema { + return { + cast_as: 'string', + indexes: { + unique: { token_filters: [] }, + ore: {}, + match: { + ...this.matchOpts, + tokenizer: { ...this.matchOpts.tokenizer }, + token_filters: this.matchOpts.token_filters.map((f) => ({ ...f })), + }, + }, + } + } +} +``` + +- [ ] **Step 5: Add all concrete classes and builder functions** + +Add these class/function pairs exactly, using the domain constants from Step 1: + +```ts +export class EncryptedInt4Column extends EncryptedV3Column<typeof INT4> {} +export const encryptedInt4Column = (columnName: string) => new EncryptedInt4Column(columnName, INT4) + +export class EncryptedInt4EqColumn extends EncryptedV3Column<typeof INT4_EQ> {} +export const encryptedInt4EqColumn = (columnName: string) => new EncryptedInt4EqColumn(columnName, INT4_EQ) + +export class EncryptedInt4OrdOreColumn extends EncryptedV3Column<typeof INT4_ORD_ORE> {} +export const encryptedInt4OrdOreColumn = (columnName: string) => new EncryptedInt4OrdOreColumn(columnName, INT4_ORD_ORE) + +export class EncryptedInt4OrdColumn extends EncryptedV3Column<typeof INT4_ORD> {} +export const encryptedInt4OrdColumn = (columnName: string) => new EncryptedInt4OrdColumn(columnName, INT4_ORD) +``` + +Repeat this exact pattern for: + +```text +Int2: int2, int2_eq, int2_ord_ore, int2_ord -> castAs number +Int8: int8, int8_eq, int8_ord_ore, int8_ord -> castAs bigint +Date: date, date_eq, date_ord_ore, date_ord -> castAs date +Timestamptz: timestamptz, timestamptz_eq, timestamptz_ord_ore, timestamptz_ord -> castAs date +Numeric: numeric, numeric_eq, numeric_ord_ore, numeric_ord -> castAs number +Text: text, text_eq, text_match, text_ord_ore, text_ord -> castAs string +Bool: bool -> castAs boolean +Float4: float4, float4_eq, float4_ord_ore, float4_ord -> castAs number +Float8: float8, float8_eq, float8_ord_ore, float8_ord -> castAs number +``` + +For `text_match`, use `MATCH_ONLY`. + +After adding all classes, add a compile-time guard test in `schema-v3.test-d.ts`: + +```ts +it('v3 domain classes remain nominal by literal domain definition', () => { + const int8 = encryptedInt8Column('id64') + const bool = encryptedBoolColumn('active') + + expectTypeOf(int8).not.toEqualTypeOf<typeof bool>() + + // @ts-expect-error - storage-only bool is not assignable to storage-only int8 + const invalid: typeof int8 = bool + void invalid +}) +``` + +- [ ] **Step 6: Run runtime schema tests** + +Run: + +```bash +pnpm --filter @cipherstash/stack vitest run __tests__/schema-v3.test.ts +``` + +Expected: PASS for schema-v3 runtime tests. If class constructor visibility fails, make the base class constructor `public`. + +--- + +### Task 4: Generalize v3 Table Column Types And Inference + +**Files:** +- Modify: `packages/stack/src/schema/v3/index.ts` +- Modify: `packages/stack/__tests__/schema-v3.test-d.ts` + +- [ ] **Step 1: Replace single-column v3 table type** + +In `schema/v3/index.ts`, replace: + +```ts +export type EncryptedV3TableColumn = { + [key: string]: EncryptedTextSearchColumn +} +``` + +with: + +```ts +export type AnyEncryptedV3Column = + | EncryptedInt4Column + | EncryptedInt4EqColumn + | EncryptedInt4OrdOreColumn + | EncryptedInt4OrdColumn + | EncryptedInt2Column + | EncryptedInt2EqColumn + | EncryptedInt2OrdOreColumn + | EncryptedInt2OrdColumn + | EncryptedInt8Column + | EncryptedInt8EqColumn + | EncryptedInt8OrdOreColumn + | EncryptedInt8OrdColumn + | EncryptedDateColumn + | EncryptedDateEqColumn + | EncryptedDateOrdOreColumn + | EncryptedDateOrdColumn + | EncryptedTimestamptzColumn + | EncryptedTimestamptzEqColumn + | EncryptedTimestamptzOrdOreColumn + | EncryptedTimestamptzOrdColumn + | EncryptedNumericColumn + | EncryptedNumericEqColumn + | EncryptedNumericOrdOreColumn + | EncryptedNumericOrdColumn + | EncryptedTextColumn + | EncryptedTextEqColumn + | EncryptedTextMatchColumn + | EncryptedTextOrdOreColumn + | EncryptedTextOrdColumn + | EncryptedTextSearchColumn + | EncryptedBoolColumn + | EncryptedFloat4Column + | EncryptedFloat4EqColumn + | EncryptedFloat4OrdOreColumn + | EncryptedFloat4OrdColumn + | EncryptedFloat8Column + | EncryptedFloat8EqColumn + | EncryptedFloat8OrdOreColumn + | EncryptedFloat8OrdColumn + +export type EncryptedV3TableColumn = { + [key: string]: AnyEncryptedV3Column +} +``` + +- [ ] **Step 2: Add plaintext inference by literal domain definition** + +Add: + +```ts +type PlaintextFromKind<K extends PlaintextKind> = + K extends 'string' + ? string + : K extends 'number' + ? number + : K extends 'bigint' + ? bigint + : K extends 'boolean' + ? boolean + : K extends 'date' + ? Date + : never + +type PlaintextForColumn<C> = + C extends EncryptedV3Column<infer D> + ? PlaintextFromKind<D['castAs']> + : never +``` + +Do not infer plaintext from a long subclass conditional. Empty subclasses that share the same base generic are structurally assignable; the private base field carrying the full literal domain definition is the stable type discriminator. + +Then replace `InferPlaintext` with: + +```ts +export type InferPlaintext<T extends EncryptedTable<EncryptedV3TableColumn>> = + T extends EncryptedTable<infer C> + ? { [K in keyof C]: PlaintextForColumn<C[K]> } + : never +``` + +Keep `InferEncrypted` as `{ [K in keyof C]: Encrypted }`. + +- [ ] **Step 3: Add type tests for mixed v3 table inference** + +In `schema-v3.test-d.ts`, add: + +```ts +it('InferPlaintext maps v3 concrete domains to plaintext TypeScript types', () => { + const metrics = encryptedTable('metrics', { + name: encryptedTextColumn('name'), + age: encryptedInt4Column('age'), + id64: encryptedInt8Column('id64'), + active: encryptedBoolColumn('active'), + createdAt: encryptedTimestamptzColumn('created_at'), + score: encryptedFloat8Column('score'), + }) + + type Plaintext = InferPlaintext<typeof metrics> + + expectTypeOf<Plaintext>().toEqualTypeOf<{ + name: string + age: number + id64: bigint + active: boolean + createdAt: Date + score: number + }>() +}) +``` + +- [ ] **Step 4: Run type tests and confirm expected failure before query type fixes** + +Run: + +```bash +pnpm --filter @cipherstash/stack test:types +``` + +Expected at this point: may FAIL because `BuildableQueryColumn` still accepts storage-only v3 columns. Continue to Task 5 before requiring a full pass. + +--- + +### Task 5: Require v3 Query Capability Metadata For `encryptQuery` + +**Files:** +- Modify: `packages/stack/src/types.ts` +- Modify: `packages/stack/__tests__/schema-v3.test-d.ts` + +- [ ] **Step 1: Tighten `BuildableQueryColumn`** + +In `types.ts`, replace: + +```ts +export type BuildableQueryColumn = + | EncryptedColumn + | (BuildableColumn & { getEqlType(): string }) +``` + +with: + +```ts +export interface BuildableV3QueryableColumn extends BuildableColumn { + getEqlType(): string + getQueryCapabilities(): { + equality: boolean + orderAndRange: boolean + freeTextSearch: boolean + } + isQueryable(): true +} + +export type BuildableQueryColumn = EncryptedColumn | BuildableV3QueryableColumn +``` + +- [ ] **Step 2: Add positive and negative queryability type tests** + +In `schema-v3.test-d.ts`, add: + +```ts +it('encryptQuery accepts queryable v3 columns with explicit capability metadata', () => { + const users = encryptedTable('users', { + emailEq: encryptedTextEqColumn('email_eq'), + emailMatch: encryptedTextMatchColumn('email_match'), + emailSearch: encryptedTextSearchColumn('email_search'), + createdAt: encryptedTimestamptzOrdColumn('created_at'), + }) + const client = {} as EncryptionClient + + expectTypeOf(client.encryptQuery).toBeCallableWith('alice@example.com', { + table: users, + column: users.emailEq, + }) + expectTypeOf(client.encryptQuery).toBeCallableWith('ali', { + table: users, + column: users.emailMatch, + queryType: 'freeTextSearch', + }) + expectTypeOf(client.encryptQuery).toBeCallableWith(new Date(), { + table: users, + column: users.createdAt, + queryType: 'orderAndRange', + }) + expectTypeOf(client.encryptQuery).toBeCallableWith('alice@example.com', { + table: users, + column: users.emailSearch, + queryType: 'equality', + }) +}) + +it('encryptQuery rejects storage-only v3 columns at compile time', () => { + const users = encryptedTable('users', { + email: encryptedTextColumn('email'), + active: encryptedBoolColumn('active'), + }) + const client = {} as EncryptionClient + + client.encryptQuery('alice@example.com', { + table: users, + // @ts-expect-error - storage-only v3 text column is not queryable + column: users.email, + }) + + client.encryptQuery(true, { + table: users, + // @ts-expect-error - storage-only v3 bool column is not queryable + column: users.active, + }) +}) +``` + +- [ ] **Step 3: Preserve literal `isQueryable()` inference in the base class** + +In `schema/v3/index.ts`, storage-only class instances must have `isQueryable(): false` inferred through `QueryableFlag<D>`, and queryable class instances must have `isQueryable(): true`. Do not add per-class overrides unless TypeScript proves the base method fails; 40 overrides add noise and are not needed when domain constants remain `as const`. + +- [ ] **Step 4: Add runtime capability-misuse tests** + +In `schema-v3.test.ts`, import `resolveIndexType` from `@/encryption/helpers/infer-index-type` and add tests that call the query helper path with unsupported query types: + +```ts +it('throws when querying a storage-only v3 column at runtime', () => { + const raw = encryptedTextColumn('raw') + expect(() => resolveIndexType(raw as never)).toThrow(/no indexes configured/) +}) + +it('throws when a query type is not configured on a queryable v3 column', () => { + const matchOnly = encryptedTextMatchColumn('body') + expect(() => resolveIndexType(matchOnly, 'equality')).toThrow( + /Index type "unique" is not configured/, + ) + expect(() => resolveIndexType(matchOnly, 'orderAndRange')).toThrow( + /Index type "ore" is not configured/, + ) +}) +``` + +- [ ] **Step 5: Run type tests** + +Run: + +```bash +pnpm --filter @cipherstash/stack test:types +``` + +Expected: PASS for `schema-v3.test-d.ts` and existing v2 compatibility type tests. + +Do not make these tests green by weakening `toEqualTypeOf` assertions to `toMatchTypeOf`. The failure mode being guarded here is over-broad inference, so exact type equality is required. + +--- + +### Task 6: Structurally Widen Model Encryption For v3 Tables + +**Files:** +- Modify: `packages/stack/src/types.ts` +- Modify: `packages/stack/src/encryption/index.ts` +- Modify: `packages/stack/src/encryption/helpers/model-helpers.ts` +- Modify: `packages/stack/src/encryption/operations/encrypt-model.ts` +- Modify: `packages/stack/src/encryption/operations/bulk-encrypt-models.ts` +- Modify: `packages/stack/__tests__/schema-v3.test-d.ts` + +- [ ] **Step 1: Add structural model schema types** + +In `types.ts`, add after `BuildableTable`: + +```ts +export type BuildableTableColumns<T extends BuildableTable> = + T extends { readonly _columnType: infer C } + ? C extends Record<string, unknown> + ? C + : never + : never + +export type EncryptedFromBuildableTable<T, Table extends BuildableTable> = { + [K in keyof T]: [K] extends [keyof BuildableTableColumns<Table>] + ? null extends T[K] + ? Encrypted | null + : Encrypted + : T[K] +} +``` + +This must use the table's existing `_columnType` brand, not `build().columns`. `build()` intentionally returns `Record<string, ColumnSchema>`, which erases literal keys and would mark every model field as encrypted. Keep existing `EncryptedFromSchema` for v2 backward compatibility. + +- [ ] **Step 2: Update client model method signatures** + +In `encryption/index.ts`, change: + +```ts +encryptModel< + T extends Record<string, unknown>, + S extends EncryptedTableColumn = EncryptedTableColumn, +>( + input: T, + table: EncryptedTable<S>, +): EncryptModelOperation<EncryptedFromSchema<T, S>> +``` + +to: + +```ts +encryptModel< + T extends Record<string, unknown>, + Table extends BuildableTable, +>( + input: T, + table: Table, +): EncryptModelOperation<EncryptedFromBuildableTable<T, Table>> +``` + +Change `bulkEncryptModels` similarly: + +```ts +bulkEncryptModels< + T extends Record<string, unknown>, + Table extends BuildableTable, +>( + input: Array<T>, + table: Table, +): BulkEncryptModelsOperation<EncryptedFromBuildableTable<T, Table>> +``` + +Add imports for `BuildableTable` and `EncryptedFromBuildableTable`. + +- [ ] **Step 3: Update helper and operation table types** + +In all listed files, replace: + +```ts +EncryptedTable<EncryptedTableColumn> +``` + +with: + +```ts +BuildableTable +``` + +For imports, remove v2 schema table imports and import `BuildableTable` from `@/types`. + +Affected functions/properties: + +```ts +prepareFieldsForEncryption(..., table: BuildableTable) +encryptModelFields(..., table: BuildableTable) +encryptModelFieldsWithLockContext(..., table: BuildableTable) +prepareBulkModelsForOperation(..., table?: BuildableTable) +bulkEncryptModels(..., table: BuildableTable) +bulkEncryptModelsWithLockContext(..., table: BuildableTable) +EncryptModelOperation.table +EncryptModelOperation.constructor table +EncryptModelOperation.getOperation().table +BulkEncryptModelsOperation.table +BulkEncryptModelsOperation.constructor table +BulkEncryptModelsOperation.getOperation().table +``` + +- [ ] **Step 4: Add model type tests for v3 tables** + +In `schema-v3.test-d.ts`, add: + +```ts +it('encryptModel and bulkEncryptModels infer encrypted fields from v3 tables', () => { + const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), + active: encryptedBoolColumn('active'), + }) + const client = {} as EncryptionClient + + const encryptedOne = client.encryptModel( + { id: 'u1', email: 'alice@example.com', active: true, untouched: 42 }, + users, + ) + expectTypeOf(encryptedOne).toEqualTypeOf< + import('@/encryption').EncryptModelOperation<{ + id: string + email: Encrypted + active: Encrypted + untouched: number + }> + >() + + const encryptedMany = client.bulkEncryptModels( + [{ id: 'u1', email: 'alice@example.com', active: true }], + users, + ) + expectTypeOf(encryptedMany).toEqualTypeOf< + import('@/encryption').BulkEncryptModelsOperation< + { + id: string + email: Encrypted + active: Encrypted + } + > + >() +}) +``` + +Add nullable and v2 re-pinning cases: + +```ts +it('v3 encryptModel preserves unrelated and nullable fields', () => { + const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), + }) + const client = {} as EncryptionClient + + const encrypted = client.encryptModel( + { id: 'u1', email: null as string | null, untouched: 42 }, + users, + ) + + expectTypeOf(encrypted).toEqualTypeOf< + import('@/encryption').EncryptModelOperation<{ + id: string + email: Encrypted | null + untouched: number + }> + >() +}) + +it('v2 encryptModel inference still preserves non-schema fields after widening', () => { + const users = v2EncryptedTable('users', { + email: encryptedColumn('email').equality(), + }) + const client = {} as EncryptionClient + + const encrypted = client.encryptModel( + { id: 'u1', email: 'alice@example.com', age: 30 }, + users, + ) + + expectTypeOf(encrypted).toEqualTypeOf< + import('@/encryption').EncryptModelOperation<{ + id: string + email: Encrypted + age: number + }> + >() +}) +``` + +- [ ] **Step 5: Run targeted type tests** + +Run: + +```bash +pnpm --filter @cipherstash/stack test:types +``` + +Expected: PASS. Existing v2 model typing should remain accepted. + +--- + +### Task 7: Add Runtime Client Tests For Representative v3 Domains + +**Files:** +- Modify: `packages/stack/__tests__/schema-v3-client.test.ts` + +- [ ] **Step 1: Expand schema with representative domains** + +Replace the current `users` schema with: + +```ts +const users = encryptedTable('schema_v3_client_users', { + email: encryptedTextSearchColumn('email'), + age: encryptedInt4OrdColumn('age'), + nickname: encryptedTextEqColumn('nickname'), + body: encryptedTextMatchColumn('body'), + notes: encryptedTextColumn('notes'), + active: encryptedBoolColumn('active'), + externalId: encryptedInt8Column('external_id'), + createdOn: encryptedDateColumn('created_on'), + occurredAt: encryptedTimestamptzColumn('occurred_at'), +}) +``` + +- [ ] **Step 2: Add env-gated storage-only encryption tests** + +Add: + +```ts +it('encrypts and decrypts storage-only v3 columns', async () => { + const encryptedText = unwrapResult( + await protectClient.encrypt('private note', { + table: users, + column: users.notes, + }), + ) + expect(encryptedText).toMatchObject({ + i: { t: 'schema_v3_client_users', c: 'notes' }, + v: 2, + }) + expect(encryptedText).toHaveProperty('c') + expect(encryptedText).not.toHaveProperty('hm') + expect(encryptedText).not.toHaveProperty('bf') + expect(encryptedText).not.toHaveProperty('ob') + expect(unwrapResult(await protectClient.decrypt(encryptedText))).toBe('private note') + + const encryptedBool = unwrapResult( + await protectClient.encrypt(true, { + table: users, + column: users.active, + }), + ) + expect(encryptedBool).toHaveProperty('c') + expect(unwrapResult(await protectClient.decrypt(encryptedBool))).toBe(true) +}, 30000) +``` + +- [ ] **Step 3: Add representative query tests** + +Add: + +```ts +it('encrypts equality and order query terms for typed v3 columns', async () => { + const equalityTerm = unwrapResult( + await protectClient.encryptQuery('ada', { + table: users, + column: users.nickname, + }), + ) + expect(equalityTerm).toHaveProperty('hm') + expect(equalityTerm).not.toHaveProperty('c') + + const orderTerm = unwrapResult( + await protectClient.encryptQuery(37, { + table: users, + column: users.age, + queryType: 'orderAndRange', + }), + ) + expect(orderTerm).toHaveProperty('ob') + expect(orderTerm).not.toHaveProperty('c') +}, 30000) +``` + +- [ ] **Step 4: Add `text_match`, bigint, and Date live checks** + +Add: + +```ts +it('encrypts free-text terms for text_match columns', async () => { + const encrypted = unwrapResult( + await protectClient.encrypt('Ada Lovelace wrote notes', { + table: users, + column: users.body, + }), + ) + expect(encrypted).toHaveProperty('c') + expect(encrypted).toHaveProperty('bf') + expect(encrypted).not.toHaveProperty('hm') + expect(encrypted).not.toHaveProperty('ob') + + const matchTerm = unwrapResult( + await protectClient.encryptQuery('Lovelace', { + table: users, + column: users.body, + queryType: 'freeTextSearch', + }), + ) + expect(matchTerm).toHaveProperty('bf') + expect(matchTerm).not.toHaveProperty('c') +}, 30000) + +it('round-trips representative bigint and date-like v3 storage domains', async () => { + const int8Encrypted = unwrapResult( + await protectClient.encrypt(1234567890123456789n, { + table: users, + column: users.externalId, + }), + ) + expect(unwrapResult(await protectClient.decrypt(int8Encrypted))).toBe(1234567890123456789n) + + const day = new Date('2026-07-01T00:00:00.000Z') + const dateEncrypted = unwrapResult( + await protectClient.encrypt(day, { + table: users, + column: users.createdOn, + }), + ) + expect(unwrapResult(await protectClient.decrypt(dateEncrypted))).toEqual(day) +}, 30000) +``` + +- [ ] **Step 5: Run without credentials to verify skip behavior** + +Run: + +```bash +env -u CS_WORKSPACE_CRN -u CS_CLIENT_ID -u CS_CLIENT_KEY -u CS_CLIENT_ACCESS_KEY pnpm --filter @cipherstash/stack vitest run __tests__/schema-v3-client.test.ts +``` + +Expected: PASS with suite skipped; no module-load throw. + +- [ ] **Step 6: Run with credentials when available** + +Run: + +```bash +pnpm --filter @cipherstash/stack vitest run __tests__/schema-v3-client.test.ts +``` + +Expected: +- If `CS_*` env vars are missing: PASS skipped. +- If `CS_*` env vars are present: PASS all live tests. + +--- + +### Task 8: Preserve And Broaden Postgres v3 Tests Safely + +**Files:** +- Modify: `packages/stack/__tests__/schema-v3-pg.test.ts` + +- [ ] **Step 1: Keep `text_search` Postgres tests unchanged unless they fail** + +Preserve: + +```ts +const LIVE_EQL_V3_PG_ENABLED = Boolean( + process.env.DATABASE_URL && + process.env.CS_WORKSPACE_CRN && + process.env.CS_CLIENT_ID && + process.env.CS_CLIENT_KEY && + process.env.CS_CLIENT_ACCESS_KEY, +) +const describeLivePg = LIVE_EQL_V3_PG_ENABLED ? describe : describe.skip +``` + +- [ ] **Step 2: Add one representative typed-column table when fixture supports it** + +Before adding tests, run: + +```bash +rg "CREATE DOMAIN|CREATE TYPE" packages/stack/__tests__/fixtures/eql-v3/cipherstash-encrypt-v3.sql | rg "int4_ord|text_eq|bool" +``` + +Expected: output includes `eql_v3.int4_ord`, `eql_v3.text_eq`, and `eql_v3.bool`. + +If those exact domains are present, add a second schema: + +```ts +const typedTable = encryptedTable('protect_ci_v3_typed_domains', { + age: encryptedInt4OrdColumn('age'), + nickname: encryptedTextEqColumn('nickname'), + active: encryptedBoolColumn('active'), +}) +``` + +and create: + +```sql +CREATE TABLE IF NOT EXISTS protect_ci_v3_typed_domains ( + id INTEGER PRIMARY KEY GENERATED ALWAYS AS IDENTITY, + age eql_v3.int4_ord NOT NULL, + nickname eql_v3.text_eq NOT NULL, + active eql_v3.bool NOT NULL, + test_run_id TEXT NOT NULL +) +``` + +- [ ] **Step 3: Add representative PG roundtrip/query test if fixture supports domains** + +Add: + +```ts +it('round-trips and queries representative typed v3 domains', async () => { + const age = unwrapResult(await protectClient.encrypt(37, { table: typedTable, column: typedTable.age })) + const nickname = unwrapResult(await protectClient.encrypt('ada', { table: typedTable, column: typedTable.nickname })) + const active = unwrapResult(await protectClient.encrypt(true, { table: typedTable, column: typedTable.active })) + + const [inserted] = await sql<{ id: number }[]>` + INSERT INTO protect_ci_v3_typed_domains (age, nickname, active, test_run_id) + VALUES ( + ${sql.json(age as postgres.JSONValue)}::eql_v3.int4_ord, + ${sql.json(nickname as postgres.JSONValue)}::eql_v3.text_eq, + ${sql.json(active as postgres.JSONValue)}::eql_v3.bool, + ${TEST_RUN_ID} + ) + RETURNING id + ` + + const ageTerm = unwrapResult(await protectClient.encryptQuery(30, { + table: typedTable, + column: typedTable.age, + queryType: 'orderAndRange', + })) as postgres.JSONValue + + const rows = await sql<{ id: number }[]>` + SELECT id + FROM protect_ci_v3_typed_domains + WHERE test_run_id = ${TEST_RUN_ID} + AND eql_v3.ord_term(age) >= eql_v3.ore_block_256(${sql.json(ageTerm)}::jsonb) + ` + + expect(rows.map((row) => row.id)).toContain(inserted.id) +}, 30000) +``` + +If the fixture does not expose these exact domains, do not add this test. Keep existing `text_search` PG coverage as the live SQL proof for this pass. + +- [ ] **Step 4: Verify skip and live behavior** + +Run: + +```bash +env -u DATABASE_URL pnpm --filter @cipherstash/stack vitest run __tests__/schema-v3-pg.test.ts +``` + +Expected: PASS skipped; no module-load throw. + +Run with DB/env only when available: + +```bash +pnpm --filter @cipherstash/stack vitest run __tests__/schema-v3-pg.test.ts +``` + +Expected: +- Missing env: PASS skipped. +- Present env and fixture installed: PASS. + +--- + +### Task 9: Fix Or Isolate `wasm-inline-column-name.test.ts` Import Resolution + +**Files:** +- Modify: `packages/stack/vitest.config.ts` +- Modify only if needed: `packages/stack/__tests__/wasm-inline-column-name.test.ts` + +- [ ] **Step 1: Reproduce current failure** + +Run: + +```bash +pnpm --filter @cipherstash/stack vitest run __tests__/wasm-inline-column-name.test.ts +``` + +Expected current failure: Vitest cannot resolve or load `@cipherstash/protect-ffi/wasm-inline`. + +- [ ] **Step 2: Prefer local mocks for this unit test** + +At the top of `wasm-inline-column-name.test.ts`, before importing `../src/wasm-inline`, add: + +```ts +import { vi } from 'vitest' + +vi.mock('@cipherstash/auth/wasm-inline', () => ({ + AccessKeyStrategy: { + create: vi.fn(), + }, +})) + +vi.mock('@cipherstash/protect-ffi/wasm-inline', () => ({ + decrypt: vi.fn(), + encrypt: vi.fn(), + isEncrypted: vi.fn(), + newClient: vi.fn(), +})) +``` + +This test only covers `getColumnName`; it does not need real WASM. + +- [ ] **Step 3: Add Vitest alias only if mocking does not resolve import evaluation** + +Inspect package path: + +```bash +node -p "require.resolve('@cipherstash/protect-ffi/package.json')" +``` + +Inspect exports: + +```bash +node -p "JSON.stringify(require('@cipherstash/protect-ffi/package.json').exports, null, 2)" +``` + +If the export points to a concrete JS file and mocks are insufficient, add an alias in `vitest.config.ts` using the actual export path. + +- [ ] **Step 4: Run the focused test** + +Run: + +```bash +pnpm --filter @cipherstash/stack vitest run __tests__/wasm-inline-column-name.test.ts +``` + +Expected: PASS. + +--- + +### Task 10: Validate Package Export And Build Compatibility + +**Files:** +- Modify only if failing: `packages/stack/package.json` +- Modify only if failing: `packages/stack/tsup.config.ts` + +- [ ] **Step 1: Confirm `schema/v3` remains exported for ESM and CJS** + +Run: + +```bash +node -p "const p=require('./packages/stack/package.json'); p.exports['./schema/v3']" +``` + +Expected includes both: + +```text +import.types ./dist/schema/v3/index.d.ts +import.default ./dist/schema/v3/index.js +require.types ./dist/schema/v3/index.d.cts +require.default ./dist/schema/v3/index.cjs +``` + +- [ ] **Step 2: Confirm tsup includes v3 entry** + +Run: + +```bash +rg "src/schema/v3/index.ts" packages/stack/tsup.config.ts +``` + +Expected: one match in the main dual-format entry list. + +- [ ] **Step 3: Build stack package** + +Run: + +```bash +pnpm --filter @cipherstash/stack build +``` + +Expected: PASS. `dist/schema/v3/index.d.ts`, `.d.cts`, `.js`, and `.cjs` are generated. + +- [ ] **Step 4: Verify CJS require remains supported** + +Run: + +```bash +pnpm --filter @cipherstash/stack vitest run __tests__/cjs-require.test.ts +``` + +Expected: PASS. If no v3 CJS assertion exists, add: + +```ts +const schemaV3 = require('@cipherstash/stack/schema/v3') +expect(typeof schemaV3.encryptedTextSearchColumn).toBe('function') +expect(typeof schemaV3.encryptedInt4Column).toBe('function') +``` + +--- + +### Task 11: Add Changeset + +**Files:** +- Create: `.changeset/eql-v3-typed-schema.md` + +- [ ] **Step 1: Add changeset file** + +Create: + +```md +--- +'@cipherstash/stack': minor +--- + +Add EQL v3 schema builders for all generated SQL domains under `@cipherstash/stack/schema/v3`, including explicit query capability metadata and v3 table support in model encryption helpers. +``` + +- [ ] **Step 2: Verify changeset format** + +Run: + +```bash +pnpm changeset status +``` + +Expected: command reports a pending minor changeset for `@cipherstash/stack`. + +--- + +### Task 12: Full Verification Pass + +**Files:** +- All changed files above. + +- [ ] **Step 1: Run formatter/fixer** + +Run: + +```bash +pnpm run code:fix +``` + +Expected: PASS; files may be formatted. + +- [ ] **Step 2: Run focused stack tests** + +Run: + +```bash +pnpm --filter @cipherstash/stack vitest run __tests__/schema-v3.test.ts __tests__/schema-v3-client.test.ts __tests__/schema-v3-pg.test.ts __tests__/wasm-inline-column-name.test.ts +``` + +Expected: +- Unit tests PASS. +- Live tests PASS skipped when env vars are missing. +- No module-load failures when env vars are missing. + +- [ ] **Step 3: Run type tests** + +Run: + +```bash +pnpm --filter @cipherstash/stack test:types +``` + +Expected: PASS. + +- [ ] **Step 4: Run package build** + +Run: + +```bash +pnpm --filter @cipherstash/stack build +``` + +Expected: PASS. + +- [ ] **Step 5: Run package test suite if credentials are available** + +Run: + +```bash +pnpm --filter @cipherstash/stack test +``` + +Expected: +- With credentials: PASS, including live tests. +- Without credentials: PASS for unit tests and env-gated live suites skipped. If unrelated existing live tests fail due to missing `CS_*`, record that explicitly in the final implementation notes. + +--- + +## Commit Plan + +- [ ] Commit 1: `test: cover eql v3 typed schema domains` + - Include `schema-v3.test.ts` and `schema-v3.test-d.ts` failing tests. +- [ ] Commit 2: `feat: add eql v3 domain builders` + - Include `schema/v3/index.ts`. +- [ ] Commit 3: `feat: support v3 tables in model encryption` + - Include `types.ts`, encryption client/helper/operation files, and model type tests. +- [ ] Commit 4: `test: stabilize v3 client and wasm-inline coverage` + - Include live test updates and Vitest/WASM test fix. +- [ ] Commit 5: `changeset: document eql v3 typed schema` + - Include `.changeset/eql-v3-typed-schema.md`. + +--- + +## Self-Review + +**Spec coverage:** This plan keeps v3 isolated under `@cipherstash/stack/schema/v3`, exports one builder per EQL v3 domain, preserves v2 schema, adds explicit `getQueryCapabilities()` and `isQueryable()`, tightens `BuildableQueryColumn`, widens model helpers structurally, preserves `text_search` byte-equivalent config, keeps `EncryptConfig` free of v3 metadata, env-gates live tests, and addresses `wasm-inline` Vitest resolution. + +**Review-driven corrections:** The design intentionally uses a full literal domain definition generic (`eqlType`, `castAs`, and capabilities), not a capability-only generic, because empty TypeScript subclasses are not nominal. Model encryption inference intentionally reads table keys from the existing `_columnType` brand, not `build().columns`, because the structural `BuildableTable.build()` contract erases literal keys to `Record<string, ColumnSchema>`. + +**Placeholder scan:** No task uses unresolved placeholders. Conditional Postgres expansion is tied to a concrete `rg` command and an explicit keep-existing-tests outcome. + +**Type consistency:** Public capability names are consistently `equality`, `orderAndRange`, and `freeTextSearch`. Queryable v3 columns require `isQueryable(): true`; storage-only columns return `false` and remain accepted by `encrypt` through `BuildableColumn`. diff --git a/docs/superpowers/specs/2026-06-30-eql-v3-text-search-schema-design.md b/docs/superpowers/specs/2026-06-30-eql-v3-text-search-schema-design.md new file mode 100644 index 00000000..6773fc53 --- /dev/null +++ b/docs/superpowers/specs/2026-06-30-eql-v3-text-search-schema-design.md @@ -0,0 +1,340 @@ +# EQL v3 Schema DSL — `text_search` (Increment 1) + +> **Superseded (re-baseline, 2026-07-05):** written against the +> pre-`eql-3.0.0-alpha.2` EQL v3 surface — old domain names (`int4`, +> `timestamptz`, …, since renamed to SQL-standard `integer`, `timestamp`, …), +> `v: 2` envelope pins, and no `eql_v3_internal` schema. Retained as a +> historical design record; the shipped surface is the re-baselined one. + +> **Superseded (2026-07-03):** the authoring surface described below has moved. +> The subpath is now `@cipherstash/stack/eql/v3` (not `schema/v3`) and columns +> are authored via the `types` namespace — `types.TextSearch('email')` replaces +> `encryptedTextSearchColumn('email')`. This document is retained as the original +> design record for the increment; the code examples show the historical API. + +**Date:** 2026-06-30 +**Status:** Approved (design) +**Package:** `@cipherstash/stack` +**Scope:** Authoring DSL + encrypt-config emission for the `eql_v3.text_search` +concrete type, **plus** a backward-compatible structural widening of the public +client types so v3 builders are first-class with the client API (`Encryption`, +`encrypt`, `decrypt`, `encryptQuery`). DDL and query-dialect work are explicitly +deferred (see Non-goals). + +--- + +## Goal + +Begin the EQL v3 version of the encryption SDK. EQL v3 removes the generic +"encrypted" concept in favour of **concrete types that carry their own +capabilities**. The first concrete type is `eql_v3.text_search`. + +Today: + +```ts +const users = encryptedTable('users', { + email: encryptedColumn('email').equality().freeTextSearch(), +}) +``` + +v3: + +```ts +const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), +}) +``` + +Because the concrete type carries capability, the capability-enabling calls +(`.equality()`, `.orderAndRange()`, `.freeTextSearch()` *as enablers*) disappear. +What remains is **tuning** of the match index: + +```ts +const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email').freeTextSearch({ + tokenizer: { kind: 'ngram', token_length: 4 }, + token_filters: [{ kind: 'downcase' }], + k: 8, + m: 4096, + include_original: false, + }), +}) +``` + +## Background — what `eql_v3.text_search` is + +Source of truth: +`<eql-v3-worktree>/release/cipherstash-encrypt-v3.sql`. + +`eql_v3.text_search` is a Postgres `CREATE DOMAIN ... AS jsonb` whose `CHECK` +requires an object containing `v, i, c, hm, ob, bf` (with `v = '2'`). The domain +defines **all three** index extractors as functions: + +- `eql_v3.eq_term(text_search)` → equality (`hm` = hmac) +- `eql_v3.ord_term(text_search)` → order/range (`ob` = ore blocks) +- `eql_v3.match_term(text_search)` → free-text match (`bf` = bloom filter) + +So `text_search` is the **full-capability** text type: equality + order + match. +EQL v3 also defines narrower text domains (`text`, `text_eq`, `text_match`, +`text_ord(_ore)`) and full families for `int*`/`float*`/`date`/`bool`/`numeric`/ +`timestamptz`/`json` — all out of scope for this increment. + +### The load-bearing fact: the payload is identical + +The encrypted envelope a v2 column produces (`{ v, i, c, hm, ob, bf }`) already +satisfies the `eql_v3.text_search` domain `CHECK`. Therefore: + +- A v2 `eql_v2_encrypted` column built with equality + order + match can be + retyped to `eql_v3.text_search` with **no re-encryption** — a future + `ALTER COLUMN ... TYPE` is a `jsonb → jsonb` metadata flip. +- The native cipherstash-client (`@cipherstash/protect-ffi` `newClient`) needs + **no changes**: the `EncryptConfig` it receives is unchanged. +- The SDK's **runtime** encrypt/decrypt/query path needs no changes either — it + is purely structural (it only reads `column.getName()`, `column.build()`, + `table.tableName`, `table.build().columns`; there is no `instanceof` on that + path). + +What this increment *does* change is the SDK's **public TYPES**: today they are +typed against the v2 `EncryptedTable<EncryptedTableColumn>` / `EncryptedColumn` +classes, which are nominal (private fields), so the separate v3 +`EncryptedTextSearchColumn` class is not assignable to them. To make v3 builders +work with the client (not just emit a config), the public client types are +**widened to a structural contract** in this increment (see "Client integration" +below). The widening is purely additive — existing v2 usage is unaffected. + +## Architecture & location + +- New module: `packages/stack/src/schema/v3/` (own `index.ts`; split into + focused files if it grows). +- New export subpath: `@cipherstash/stack/schema/v3` (added to `package.json` + `exports` + `tsup`/build entry as needed). +- The v2 schema module (`packages/stack/src/schema/index.ts`) keeps its runtime + behavior and existing exported symbol shapes; the only permitted edit there is + a backward-compatible **widening** of `buildEncryptConfig`'s parameter type to + the shared structural table contract (it already only calls `.build()`). +- v3 builders emit the existing `ColumnSchema` / `EncryptConfig` shape, so the + encryption client, payload, encrypt/decrypt, and query paths work at runtime + with **zero runtime changes**. Client integration at the **type** level is + achieved by widening the public types (next section), not by a runtime rewrite. + +## Public API + +```ts +import { encryptedTable, encryptedTextSearchColumn } from '@cipherstash/stack/schema/v3' + +// minimal — capability is carried by the type +const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email'), +}) + +// with match-index tuning +const users = encryptedTable('users', { + email: encryptedTextSearchColumn('email').freeTextSearch({ + tokenizer: { kind: 'ngram', token_length: 4 }, + token_filters: [{ kind: 'downcase' }], + k: 8, + m: 4096, + include_original: false, + }), +}) +``` + +- `encryptedTextSearchColumn(name)` → `EncryptedTextSearchColumn`. The concrete + type **inherently enables equality + order + match**. There are no + capability-enabling methods. +- `.freeTextSearch(opts?)` is **tuning only** — it overrides the match-index + parameters. It never "enables" a capability (match is always on for this type). +- `encryptedTable(tableName, columns)` (v3) accepts v3 column builders and + assembles `{ tableName, columns }`. +- `buildEncryptConfig(...tables)` (v3) assembles an `EncryptConfig` (`v: 1`). + +> Naming note: v3 `encryptedTable` / `buildEncryptConfig` intentionally shadow the +> v2 names but live on the `/v3` subpath, so an importer picks the model by import +> path, not by symbol name. + +## Client integration (in scope) + +v3 builders must be **accepted by the client API**, not merely emit a config. The +runtime already works (structural — see "load-bearing fact"); the blocker is the +public TYPES. This increment widens them to a shared **structural contract** so +both v2 and v3 builders satisfy them: + +```ts +// minimal structural shapes — exact members verified against the client's +// actual usage (column.getName/build, table.tableName/build): +interface BuildableColumn { getName(): string; build(): ColumnSchema } +interface BuildableTable { + tableName: string + build(): { tableName: string; columns: Record<string, ColumnSchema> } +} +// Query path is NARROWER: it must reject non-queryable EncryptedField (no +// indexes). A v2 EncryptedColumn qualifies nominally; a v3 queryable concrete +// type qualifies via getEqlType(); EncryptedField is excluded. +type BuildableQueryColumn = + | EncryptedColumn + | (BuildableColumn & { getEqlType(): string }) +``` + +Widened surfaces (in `packages/stack/src/types.ts`) — note the **storage vs query split**: + +- `EncryptionClientConfig.schemas` → `AtLeastOneCsTable<BuildableTable>` +- `EncryptOptions.column` / `.table` → `BuildableColumn` / `BuildableTable` — + the STORAGE path (`encrypt`) accepts columns AND nested fields. +- `SearchTerm` / `QueryTermBase.column` → `BuildableQueryColumn`; `.table` → + `BuildableTable` — the QUERY path (`encryptQuery`) accepts only queryable + columns, so a `BuildableQueryColumn` excludes `EncryptedField` (which the + nominal `EncryptedColumn` type rejected and must keep rejecting). +- Internally, the query-only index-inference helpers + (`inferIndexType`/`validateIndexType`/`resolveIndexType`) also take + `BuildableQueryColumn` (verified reached only from the `encryptQuery` path). + +Plus `buildEncryptConfig`'s parameter is widened to `BuildableTable` (pure +widening; it only calls `.build()`). + +**v3 keeps its own `EncryptedTable` class** (it needs a different column +constraint and a simpler `build()` than v2's nested-field/ste_vec logic). Both +the v2 and v3 table/column classes satisfy the structural contract, which is what +lets a single widened type accept either. + +**Backward compatibility:** widening only — existing v2 tables/columns still +satisfy the new types (a regression type-test asserts this). The **generic +schema-aware model methods** (`encryptModel<S extends EncryptedTableColumn>` / +`bulkEncryptModels`) are **left unchanged** so v2's field-level inference +(`InferPlaintext`, `EncryptedFields`, `EncryptedFromSchema`, the +`EncryptedTable<T> & T` accessor) is preserved. v3 support for the model methods +(its columns don't satisfy `EncryptedTableColumn`) is a **future increment**. + +**Acceptance (these must type-check with v3 builders):** +`Encryption({ schemas: [v3users] })`, `client.encrypt(v, { table: v3users, column: +v3users.email })`, `client.decrypt(...)` round-trip, and +`client.encryptQuery(v, { table: v3users, column: v3users.email })`. Plus the +storage/query split: a v2 `encryptedField` is `encrypt`-able but a `@ts-expect-error` +proves it is NOT `encryptQuery`-able, and a v2 `EncryptedColumn` stays queryable. + +> Discriminator follow-up: `getEqlType()` distinguishes queryable v3 types today +> only because the one v3 type shipping (`text_search`) is queryable. If a future +> v3 *non-queryable* type also carries `getEqlType()`, switch the query-path +> discriminator to a queryability-specific marker. Not blocking for this increment. + +## `build()` output — pinned to v2 + +`encryptedTextSearchColumn('email').build()` emits exactly: + +```ts +{ + cast_as: 'string', + indexes: { + unique: { token_filters: [] }, + ore: {}, + match: { + tokenizer: { kind: 'ngram', token_length: 3 }, + token_filters: [{ kind: 'downcase' }], + k: 6, + m: 2048, + include_original: true, + }, + }, +} +``` + +Notes: + +- **`cast_as: 'string'`**, not `'text'`. The native cipherstash-client receives + the SDK-facing value verbatim; `toEqlCastAs` ('string' → 'text') is applied + only on the `wasm-inline.ts` SQL-generation path, not the `newClient` path. +- Defaults mirror v2's `freeTextSearch()` **exactly**: ngram-3, downcase filter, + `k = 6`, `m = 2048`, `include_original = true` (note: `true`, matching the v2 + builder default, not the zod-schema default of `false`). +- `unique.token_filters` defaults to `[]` (case-sensitive equality, matching v2). +- `.freeTextSearch(opts)` overrides on a per-field basis using the same merge + semantics as v2 (each provided key replaces the default; omitted keys keep the + default). + +**The guarantee:** this output is byte-identical to + +```ts +encryptedColumn('email').equality().orderAndRange().freeTextSearch().build() +``` + +and a test asserts that equality directly (see Testing). This is what makes +"swap the column type and it just works" true at the config level. + +## v3 metadata for later increments + +`EncryptedTextSearchColumn` records its concrete domain name — +`'eql_v3.text_search'` — exposed via the `getEqlType()` method (method only, no +property getter, matching the v2 builder convention). + +- `build()` (the encrypt config) does **not** include `eqlType`; the wire config + stays identical to v2. +- The name is metadata that the *future* DDL and query-dialect increments read + (per-column Postgres type, `eql_v3.eq_term(...)` lowering). Recording it now + gives those increments a hook without changing today's config. + +## Type inference + +v3 `InferPlaintext` / `InferEncrypted` mirror v2: + +- `InferPlaintext<typeof users>` → `{ email: string }` +- `InferEncrypted<typeof users>` → `{ email: Encrypted }` + +## Non-goals (deferred to follow-up increments) + +> Note: "widen the public client types" was previously implied as out of scope +> ("zero client changes"). It is now **in scope** for this increment (see Client +> integration). The items below remain deferred. + +- **v3 support in the generic schema-aware model methods** (`encryptModel` / + `bulkEncryptModels` field-level inference) — v3 columns don't satisfy the v2 + `EncryptedTableColumn` constraint those generics use. Single-value + `encrypt`/`decrypt`/`encryptQuery` + `Encryption()` config DO work in this + increment; model-method inference for v3 is a follow-up. +- **v3 columns through the WASM-inline entry** (`wasm-inline.ts`) — known + boundary. `getColumnName()` (`src/wasm-inline.ts:314-320`) runtime-checks + `instanceof EncryptedColumn || instanceof EncryptedField` and throws otherwise, + so a v3 column passed to the WASM-inline client would throw at runtime. The + type widening still compiles (the `instanceof` guard narrows the wider union) + and this path is outside the scoped typecheck, so it is a documented deferred + boundary, not a regression. The batch-2 "no `instanceof`" / structural-runtime + claim is scoped to the native `operations/*.ts` path. +- **Per-column DDL type emission** — deriving each column's Postgres type from + its v3 builder. v2 hard-codes one native type (`eql_v2_encrypted`); v3 needs a + per-column type (`eql_v3.text_search`, etc.). Net-new, touches every adapter. +- **v2 → v3 transition tooling** — `ALTER TABLE ... ALTER COLUMN ... TYPE + eql_v3.text_search` and retiring the now-redundant `eql_v2_configuration` / + `add_search_config` rows for the column. +- **v3 query dialect** — `eql_v3.eq_term(col) = eql_v3.eq_term($1::eql_v3.text_search)` + in drizzle / supabase operator lowering. +- **Other v3 concrete types** — `int*`, `float*`, `date`, `bool`, `numeric`, + `timestamptz`, `text_eq`/`text_ord`, `json`, etc. The module is structured so + these slot in later (a domain → config mapping per type). +- **Nested `encryptedField` / structured columns** for v3 — only top-level + `text_search` columns ship in increment 1. + +## Testing + +- **Config-equivalence (load-bearing):** + `encryptedTextSearchColumn('email').build()` deep-equals + `encryptedColumn('email').equality().orderAndRange().freeTextSearch().build()`. +- **`.freeTextSearch()` override:** each provided opt replaces its default; + omitted opts retain defaults; verify the documented "additional config" example + produces the expected match block. +- **Defaults:** assert the exact default `build()` output above (catches any + silent default drift). +- **`buildEncryptConfig`:** a v3 table assembles into a valid `EncryptConfig` + (`v: 1`) that passes `encryptConfigSchema.parse(...)`. +- **`eqlType` metadata:** `getEqlType()` returns `'eql_v3.text_search'` and is + absent from `build()` output. +- **No shared mutable state:** two columns built independently must not alias — + mutating one column's `build()` output must not affect another's (defaults are + produced per-instance, `build()` returns a fresh clone). +- **Type-level:** `InferPlaintext` / `InferEncrypted` produce the expected shapes. +- **Client integration (type-level):** the acceptance snippets above type-check + with v3 builders, and a regression test asserts v2 tables/columns still satisfy + the widened public types. + +## Open questions + +None blocking. Future increments will decide how `eqlType` threads into DDL and +query lowering, and how the narrower text domains (`text_eq`, `text_match`, +`text_ord`) and other scalar families are expressed in the DSL. diff --git a/docs/superpowers/specs/2026-07-02-stryker-v3-ci-gate-design.md b/docs/superpowers/specs/2026-07-02-stryker-v3-ci-gate-design.md new file mode 100644 index 00000000..a149cdad --- /dev/null +++ b/docs/superpowers/specs/2026-07-02-stryker-v3-ci-gate-design.md @@ -0,0 +1,196 @@ +# Stryker mutation testing as a blocking CI gate for EQL v3 + +Date: 2026-07-02 +Status: Proposed (awaiting review) +Branch: feat/eql-v3-text-search-schema + +## Goal + +Add StrykerJS mutation testing scoped to **EQL v3 only** +(`packages/stack/src/eql/v3/`) and wire it into CI as a **blocking** check. +The gate mirrors the existing `fta-v3.yml` complexity gate: paths-filtered to v3, +directory-scoped, and blocking (no `continue-on-error`). + +Mutation testing verifies that the v3 test suite actually *detects* changes in +behaviour — it mutates the source and fails if the tests still pass ("surviving +mutants"). This complements the FTA complexity gate (static) with a +test-effectiveness gate (dynamic). + +## Context / prior art + +- **rundown** (`~/psrc/rundown`) runs Stryker 9.6.1 across a pnpm monorepo with a + **Jest** runner, per-package configs, incremental runs backed by the public + Stryker Dashboard, a native `break: 70` aggregate threshold, and a custom + `assert-mutation-score.mjs` per-file gate. Its PR run is advisory; only the + push-to-`main`/weekly "producer" run is blocking. +- **stack** differs in ways that simplify the design considerably (below). + +## Key facts driving the design + +1. **stack uses Vitest 3.2.4, not Jest.** rundown's Jest-runner config is not + reusable. We use `@stryker-mutator/vitest-runner`. +2. **v3 scope is a small directory:** `packages/stack/src/eql/v3/` — four + cohesive files (`columns.ts`, `types.ts`, `table.ts`, `index.ts`), split out + of the former single `schema/v3/index.ts`. NOTE: an earlier draft of this + spec assumed a *single file*, from which it concluded the project-wide + aggregate score *is* that file's score and no per-file gate script was needed. + That premise no longer holds — the mutate scope is now four files. With only + four small files the aggregate is still a faithful signal, so start with an + aggregate `break` threshold only (no `assert-mutation-score.mjs`), but add + per-file gating if any one file's score later diverges from the aggregate. +3. **Live/DB tests self-skip without env.** `schema-v3-pg.test.ts` (guarded by + `DATABASE_URL` + `CS_*`) and `schema-v3-client.test.ts` (guarded by `CS_*`) + skip their `describe` blocks when the env vars are absent. So a CI run with no + Postgres service and no `.env` still runs cleanly — the live blocks skip; the + pure `schema-v3.test.ts` (~21 KB) and `typed-client-v3.test.ts` provide the + coverage. The gate stays as lean as the FTA job (no DB, no credentials). +4. **No build step needed.** Vitest transpiles TS on the fly and the tests import + from `@/eql/v3` (source, via the `@/` alias), so Stryker instruments source + directly — no `pnpm build` required. +5. **Supply-chain rule.** Tooling must be a pinned devDependency installed via + `--frozen-lockfile` (no `pnpm dlx` / `npx`), matching how `fta-cli@3.0.0` is + handled. + +## Scope decisions + +- **Mutate scope: `eql/v3` only** (`src/eql/v3/**/*.ts`). Matches the FTA + gate exactly. `src/encryption/v3.ts` is also v3 but is outside the current FTA + scope and is **excluded here** to keep the gate consistent and lean. +- **Test execution: lean, no DB.** Stryker runs only the v3 runtime test files; + the live pg/client blocks self-skip. No Postgres service is provisioned. + +## Components + +### 1. Dependencies + +Add to `packages/stack/package.json` devDependencies (pinned, matching versions, +9.x line): + +- `@stryker-mutator/core` +- `@stryker-mutator/vitest-runner` + +Update `pnpm-lock.yaml` accordingly (installed via `--frozen-lockfile` in CI). + +### 2. `packages/stack/vitest.stryker.config.ts` + +A dedicated Vitest config for mutation runs that: + +- imports/extends the base `vitest.config.ts` (keeps the `@/` alias and the + `wasm-inline` stub aliases — required for the pure tests to load), +- sets `test.include` to only the v3 runtime tests + (`__tests__/*v3*.test.ts`) so Stryker does not run the whole repo suite, +- disables the `typecheck` block (mutation testing exercises runtime behaviour, + not type tests; the `*.test-d.ts` files are excluded). + +Rationale: without scoping, Stryker's initial dry run would execute every test in +the package, wasting time and coupling the v3 gate to unrelated tests. + +### 3. `packages/stack/stryker.config.mjs` + +```js +export default { + packageManager: 'pnpm', + testRunner: 'vitest', + plugins: ['@stryker-mutator/vitest-runner'], + vitest: { configFile: 'vitest.stryker.config.ts' }, + mutate: ['src/eql/v3/**/*.ts'], + coverageAnalysis: 'perTest', + reporters: ['clear-text', 'progress', 'html', 'json'], + htmlReporter: { fileName: 'reports/mutation/index.html' }, + jsonReporter: { fileName: 'reports/mutation/mutation-report.json' }, + thresholds: { high: <TBD>, low: <TBD>, break: <BASELINE> }, + concurrency: /* env-tunable, default 2 */, + timeoutMS: /* generous default, e.g. 60000 */, +} +``` + +- `break` is the **blocking mechanism**: Stryker exits non-zero when the score + drops below it. +- **No dashboard reporter and no incremental mode** initially (YAGNI for a single + file; avoids Stryker Dashboard API-key/project setup). Reporters kept local + (html + json for artifacts/debugging, clear-text + progress for logs). +- The explicit `plugins` list is required under pnpm's isolated `node_modules` + layout — Stryker's default `@stryker-mutator/*` auto-discovery fails there + (learned from rundown). + +### 4. Script + +Add to `packages/stack/package.json` scripts: + +```json +"test:mutation": "stryker run" +``` + +### 5. `.github/workflows/stryker-v3.yml` + +A near-clone of `fta-v3.yml`: + +- `on: push (main) / pull_request (**)` with `paths:`: + - `packages/stack/src/eql/v3/**` + - `packages/stack/package.json` + - `packages/stack/stryker.config.mjs` + - `packages/stack/vitest.stryker.config.ts` + - `.github/workflows/stryker-v3.yml` +- `permissions: contents: read` +- one job on `blacksmith-4vcpu-ubuntu-2404`, `timeout-minutes: 30` +- steps: checkout → `pnpm/action-setup@v6.0.8` → `setup-node@v6` (node 22, + `cache: pnpm`) → install `node-gyp` → `pnpm install --frozen-lockfile` → + `pnpm --filter @cipherstash/stack run test:mutation` +- **No `continue-on-error`** on the Stryker step → the check is blocking. + +## Threshold calibration (how "blocking" is made safe) + +We cannot know the current v3 mutation score until Stryker runs once. +Implementation therefore includes a **baseline step**: + +1. Install deps and run `pnpm --filter @cipherstash/stack run test:mutation` + locally. +2. Record the reported mutation score for `eql/v3`. +3. Set `thresholds.break` just **below** the measured score (a small buffer, the + way FTA sets `--score-cap 72` against a current 71.08). This ensures the + current state passes while any regression that lowers the score fails the gate. +4. Set `high`/`low` to reasonable display bands (do not affect pass/fail). + +If the measured baseline is very low (tests are weak), surface that to the user +before committing a `break` value — a near-zero gate provides little protection +and we may want to improve v3 tests first. This is a decision point during +implementation, not a silent choice. + +## Testing / verification + +- Run the Stryker gate locally and confirm it exits 0 at the chosen `break`. +- Confirm the run needs **no** Postgres/credentials (live blocks skip). +- Sanity-check the gate blocks: temporarily lower `break` above the score (or + delete an assertion) and confirm a non-zero exit. +- Confirm the workflow triggers only on v3-relevant paths. + +## Out of scope (YAGNI) + +- Stryker Dashboard reporter and incremental baseline. +- Per-file gate script (`assert-mutation-score.mjs`) — deferred: start with an + aggregate `break` across the four `src/eql/v3/**` files; add per-file gating + only if one file's score later diverges from the aggregate (see fact #2). +- Advisory PR comment job. +- Postgres-backed mutation runs / mutating `src/encryption/v3.ts`. + +These can be added later if the aggregate gate proves insufficient. + +## Decisions confirmed + +- **Test execution model: lean, no DB — confirmed by the user ("Start lean").** + Stryker runs only the pure v3 tests; the live pg/client blocks self-skip. A + full DB-backed run can be added later as a separate workflow if the lean + baseline proves too weak. +- **Single workflow, no split — confirmed.** rundown's two-workflow split + (blocking producer + advisory PR) is driven by its Stryker Dashboard + incremental baseline and its advisory-PR choice, neither of which applies here. + One `stryker-v3.yml` runs on both `push: main` and `pull_request`, blocking, in + the shape of `fta-v3.yml`. A second `stryker-v3-full.yml` (DB-backed, on + main/nightly) is only introduced if/when full accuracy is wanted. + +## Deferred to implementation + +- **Exact `break` value** — deferred to the baseline measurement step (run + Stryker once, set `break` just below the measured score). If the baseline is + very low, surface it before wiring the gate. +- **Stryker `9.x` exact patch version** — pinned at implementation time. diff --git a/packages/cli/package.json b/packages/cli/package.json index 9a294704..997ac703 100644 --- a/packages/cli/package.json +++ b/packages/cli/package.json @@ -42,6 +42,7 @@ "dev": "tsup --watch", "test": "vitest run", "test:e2e": "vitest run --config vitest.integration.config.ts", + "gen:eql-v3-sql": "node scripts/build-eql-v3-sql.mjs", "lint": "biome check ." }, "dependencies": { diff --git a/packages/cli/scripts/build-eql-v3-sql.mjs b/packages/cli/scripts/build-eql-v3-sql.mjs new file mode 100644 index 00000000..e182ca61 --- /dev/null +++ b/packages/cli/scripts/build-eql-v3-sql.mjs @@ -0,0 +1,100 @@ +#!/usr/bin/env node +/** + * Vendor the EQL v3 SQL bundles into packages/cli/src/sql/. + * + * Source of truth: the `cipherstash-encrypt.sql` artifact of the upstream + * `eql-3.0.0-alpha.2` release (cipherstash/encrypt-query-language), vendored + * byte-for-byte at + * packages/stack/__tests__/fixtures/eql-v3/cipherstash-encrypt-v3.sql. + * To re-vendor: download the release asset, replace the fixture, re-run this + * script, and record the new release tag here. + * + * Outputs: + * - cipherstash-encrypt-v3.sql — full bundle, byte-identical copy + * - cipherstash-encrypt-v3-supabase.sql — Supabase variant with the + * `CREATE OPERATOR CLASS`/`FAMILY` chunks removed (they need superuser, + * which Supabase does not grant) + * + * The Supabase variant is still derived locally because upstream ships no + * Supabase variant for v3 yet. The strip mirrors the upstream build's + * `**\/*operator_class.sql` exclusion glob: the monolith annotates every + * constituent file with a `--! @file <path>` marker, so the variant drops each + * `--! @file .../operator_class.sql` chunk up to the next `--! @file` marker. + * + * Usage: node packages/cli/scripts/build-eql-v3-sql.mjs + */ +import { readFileSync, writeFileSync } from 'node:fs' +import { dirname, resolve } from 'node:path' +import { fileURLToPath } from 'node:url' + +const here = dirname(fileURLToPath(import.meta.url)) +const source = resolve( + here, + '../../stack/__tests__/fixtures/eql-v3/cipherstash-encrypt-v3.sql', +) +const outDir = resolve(here, '../src/sql') + +const FILE_MARKER = /^--! @file (.+)$/ +const EXCLUDE = /operator_class\.sql$/ + +function stripOperatorClassChunks(sql) { + // \r?\n: a CRLF-checked-out source would otherwise defeat the `$`-anchored + // EXCLUDE match (belt-and-braces — the removedChunks assertion below would + // still catch it loudly). + const lines = sql.split(/\r?\n/) + const out = [] + let skipping = false + let removedChunks = 0 + + for (const line of lines) { + const marker = line.match(FILE_MARKER) + if (marker) { + skipping = EXCLUDE.test(marker[1]) + if (skipping) removedChunks++ + } + if (!skipping) out.push(line) + } + + // Verified against eql-3.0.0-alpha.2: exactly 2 `--! @file .../operator_class.sql` + // chunks (v3/sem/ore_cllw and v3/sem/ore_block_256), together carrying all + // 4 CREATE OPERATOR CLASS/FAMILY statements in the bundle. The OPE path + // (ope_cllw) ships no opclass. Hard-coded so layout drift fails loudly. + if (removedChunks !== 2) { + throw new Error( + `Expected to remove exactly 2 operator_class chunks, removed ${removedChunks} — the bundle layout changed; review the strip logic.`, + ) + } + + const stripped = out.join('\n') + if (/CREATE OPERATOR (CLASS|FAMILY)/.test(stripped)) { + throw new Error( + 'Stripped bundle still contains CREATE OPERATOR CLASS/FAMILY statements.', + ) + } + + return stripped +} + +const sql = readFileSync(source, 'utf8') + +// Companion drift check: the full bundle must carry exactly the 4 +// CREATE OPERATOR CLASS/FAMILY statements the 2 stripped chunks account for +// (verified against eql-3.0.0-alpha.2). An opclass appearing outside an +// operator_class.sql chunk would otherwise slip into the Supabase variant +// (the post-strip scan below also guards that; this pins the source shape). +const opclassStatements = sql.match(/CREATE OPERATOR (CLASS|FAMILY)/g) ?? [] +if (opclassStatements.length !== 4) { + throw new Error( + `Expected the source bundle to contain exactly 4 CREATE OPERATOR CLASS/FAMILY statements, found ${opclassStatements.length} — the bundle layout changed; review the strip logic.`, + ) +} + +writeFileSync(resolve(outDir, 'cipherstash-encrypt-v3.sql'), sql) +writeFileSync( + resolve(outDir, 'cipherstash-encrypt-v3-supabase.sql'), + stripOperatorClassChunks(sql), +) + +console.log( + 'Wrote cipherstash-encrypt-v3.sql and cipherstash-encrypt-v3-supabase.sql', +) diff --git a/packages/cli/src/__tests__/installer.test.ts b/packages/cli/src/__tests__/installer.test.ts index 2c0e0bb5..6ed9eb91 100644 --- a/packages/cli/src/__tests__/installer.test.ts +++ b/packages/cli/src/__tests__/installer.test.ts @@ -98,7 +98,7 @@ describe('EQLInstaller', () => { it('returns true when schema exists', async () => { mockConnect.mockResolvedValue(undefined) mockQuery.mockResolvedValue({ - rows: [{ schema_name: 'eql_v2' }], + rows: [{ found: 1 }], rowCount: 1, }) mockEnd.mockResolvedValue(undefined) @@ -110,6 +110,7 @@ describe('EQLInstaller', () => { const result = await installer.isInstalled() expect(result).toBe(true) + expect(mockQuery).toHaveBeenCalledWith(expect.any(String), [['eql_v2']]) }) }) @@ -204,6 +205,135 @@ describe('EQLInstaller', () => { expect(SUPABASE_PERMISSIONS_SQL).toContain('service_role') }) + it('installs the v3 bundle and grants eql_v3 permissions with eqlVersion: 3 + supabase', async () => { + mockConnect.mockResolvedValue(undefined) + mockQuery.mockResolvedValue({ rows: [], rowCount: 0 }) + mockEnd.mockResolvedValue(undefined) + + const { EQLInstaller, SUPABASE_PERMISSIONS_SQL_V3 } = await import( + '@/installer/index.ts' + ) + const installer = new EQLInstaller({ + databaseUrl: 'postgresql://localhost:5432/test', + }) + + await installer.install({ eqlVersion: 3, supabase: true }) + + const otherCalls = mockQuery.mock.calls + .map((call: unknown[]) => call[0]) + .filter( + (sql: unknown): sql is string => + typeof sql === 'string' && + sql !== 'BEGIN' && + sql !== 'COMMIT' && + sql !== 'ROLLBACK', + ) + + expect(otherCalls).toHaveLength(2) + // The bundled SQL is the v3 Supabase variant: creates eql_v3, no + // operator classes/families (they need superuser). + expect(otherCalls[0]).toContain('eql_v3') + expect(otherCalls[0]).not.toContain('CREATE OPERATOR CLASS') + expect(otherCalls[0]).not.toContain('CREATE OPERATOR FAMILY') + // The grants are keyed to eql_v3, not eql_v2. + expect(otherCalls[1]).toBe(SUPABASE_PERMISSIONS_SQL_V3) + expect(SUPABASE_PERMISSIONS_SQL_V3).toContain('eql_v3') + expect(SUPABASE_PERMISSIONS_SQL_V3).not.toContain('eql_v2') + }) + + it('installs the full v3 bundle (with operator classes) without supabase', async () => { + mockConnect.mockResolvedValue(undefined) + mockQuery.mockResolvedValue({ rows: [], rowCount: 0 }) + mockEnd.mockResolvedValue(undefined) + + const { EQLInstaller } = await import('@/installer/index.ts') + const installer = new EQLInstaller({ + databaseUrl: 'postgresql://localhost:5432/test', + }) + + await installer.install({ eqlVersion: 3 }) + + const sqlCall = mockQuery.mock.calls.find( + (call: string[]) => + typeof call[0] === 'string' && + call[0] !== 'BEGIN' && + call[0] !== 'COMMIT', + ) + expect(sqlCall).toBeDefined() + expect(sqlCall?.[0]).toContain('eql_v3') + expect(sqlCall?.[0]).toContain('CREATE OPERATOR CLASS') + }) + + it('rejects latest: true for eqlVersion: 3', async () => { + const { EQLInstaller } = await import('@/installer/index.ts') + const installer = new EQLInstaller({ + databaseUrl: 'postgresql://localhost:5432/test', + }) + + await expect( + installer.install({ eqlVersion: 3, latest: true }), + ).rejects.toThrow('not supported for EQL v3') + }) + + it('requires BOTH eql_v3 and eql_v3_internal for isInstalled({ eqlVersion: 3 })', async () => { + mockConnect.mockResolvedValue(undefined) + mockEnd.mockResolvedValue(undefined) + + const { EQLInstaller } = await import('@/installer/index.ts') + const installer = new EQLInstaller({ + databaseUrl: 'postgresql://localhost:5432/test', + }) + + // Current-generation install: both schemas present + mockQuery.mockResolvedValue({ rows: [{ found: 2 }], rowCount: 1 }) + await expect(installer.isInstalled({ eqlVersion: 3 })).resolves.toBe(true) + expect(mockQuery).toHaveBeenCalledWith(expect.any(String), [ + ['eql_v3', 'eql_v3_internal'], + ]) + + // STALE pre-alpha.2 install: eql_v3 exists but eql_v3_internal does not + // — must report NOT installed so an install run replaces it instead of + // a stale surface silently accepting wrong-generation wire data. + mockQuery.mockResolvedValue({ rows: [{ found: 1 }], rowCount: 1 }) + await expect(installer.isInstalled({ eqlVersion: 3 })).resolves.toBe( + false, + ) + }) + + it('grants eql_v3 AND eql_v3_internal for the v3 supabase install', async () => { + mockConnect.mockResolvedValue(undefined) + mockQuery.mockResolvedValue({ rows: [], rowCount: 0 }) + mockEnd.mockResolvedValue(undefined) + + const { EQLInstaller, SUPABASE_PERMISSIONS_SQL_V3 } = await import( + '@/installer/index.ts' + ) + const installer = new EQLInstaller({ + databaseUrl: 'postgresql://localhost:5432/test', + }) + + await installer.install({ eqlVersion: 3, supabase: true }) + + const otherCalls = mockQuery.mock.calls + .map((call: unknown[]) => call[0]) + .filter( + (sql: unknown): sql is string => + typeof sql === 'string' && + sql !== 'BEGIN' && + sql !== 'COMMIT' && + sql !== 'ROLLBACK', + ) + expect(otherCalls[1]).toBe(SUPABASE_PERMISSIONS_SQL_V3) + // The eql_v3 operators call SECURITY INVOKER functions that live in + // eql_v3_internal — the roles need grants on BOTH schemas. + expect(SUPABASE_PERMISSIONS_SQL_V3).toContain( + 'GRANT USAGE ON SCHEMA eql_v3 ', + ) + expect(SUPABASE_PERMISSIONS_SQL_V3).toContain( + 'GRANT USAGE ON SCHEMA eql_v3_internal ', + ) + }) + it('rolls back on SQL execution failure', async () => { mockConnect.mockResolvedValue(undefined) mockEnd.mockResolvedValue(undefined) diff --git a/packages/cli/src/__tests__/supabase-migration.test.ts b/packages/cli/src/__tests__/supabase-migration.test.ts index f5b3b75a..a5c0d095 100644 --- a/packages/cli/src/__tests__/supabase-migration.test.ts +++ b/packages/cli/src/__tests__/supabase-migration.test.ts @@ -5,6 +5,7 @@ import { afterEach, beforeEach, describe, expect, it } from 'vitest' import { detectSupabaseProject } from '../commands/db/detect.js' import { chooseSupabaseInstallMode, + routeInstallPathForEqlVersion, validateInstallFlags, } from '../commands/db/install.js' import { @@ -242,6 +243,74 @@ describe('validateInstallFlags', () => { expect(err).toMatch(/mutually exclusive/i) }) + it('accepts --eql-version 2 and 3', () => { + expect(validateInstallFlags({ eqlVersion: '2' })).toBeNull() + expect(validateInstallFlags({ eqlVersion: '3' })).toBeNull() + expect( + validateInstallFlags({ eqlVersion: '3', supabase: true, direct: true }), + ).toBeNull() + }) + + it('rejects an unknown --eql-version value', () => { + expect(validateInstallFlags({ eqlVersion: '4' })).toMatch(/--eql-version/) + }) + + it('rejects --eql-version 3 with --drizzle, --migration, or --latest', () => { + expect(validateInstallFlags({ eqlVersion: '3', drizzle: true })).toMatch( + /--drizzle/, + ) + expect( + validateInstallFlags({ + eqlVersion: '3', + supabase: true, + migration: true, + }), + ).toMatch(/--migration/) + expect(validateInstallFlags({ eqlVersion: '3', latest: true })).toMatch( + /--latest/, + ) + // --migrations-dir only feeds the v2 Supabase migration-file path; the v3 + // direct install would silently ignore it (flagged in review of #547). + expect( + validateInstallFlags({ + eqlVersion: '3', + supabase: true, + migrationsDir: 'db/migrations', + }), + ).toMatch(/--migrations-dir/) + }) +}) + +describe('routeInstallPathForEqlVersion', () => { + it('passes v2 routing through untouched', () => { + expect( + routeInstallPathForEqlVersion(2, { supabase: false, drizzle: true }), + ).toEqual({ drizzle: true, useSupabaseInstallModeSelection: false }) + expect( + routeInstallPathForEqlVersion(2, { supabase: true, drizzle: false }), + ).toEqual({ drizzle: false, useSupabaseInstallModeSelection: true }) + }) + + it('falls back from auto-detected drizzle to direct for v3, with a notice', () => { + const routing = routeInstallPathForEqlVersion(3, { + supabase: false, + drizzle: true, + }) + expect(routing.drizzle).toBe(false) + expect(routing.useSupabaseInstallModeSelection).toBe(false) + expect(routing.notice).toMatch(/Drizzle/) + }) + + it('skips the supabase migration-vs-direct mode selection for v3', () => { + const routing = routeInstallPathForEqlVersion(3, { + supabase: true, + drizzle: false, + }) + expect(routing.drizzle).toBe(false) + expect(routing.useSupabaseInstallModeSelection).toBe(false) + expect(routing.notice).toBeUndefined() + }) + it('does NOT auto-imply --supabase from --migration', () => { // Even with --supabase: false explicitly, --migration must error. const err = validateInstallFlags({ supabase: false, migration: true }) diff --git a/packages/cli/src/bin/main.ts b/packages/cli/src/bin/main.ts index c6160178..fafce716 100644 --- a/packages/cli/src/bin/main.ts +++ b/packages/cli/src/bin/main.ts @@ -156,7 +156,9 @@ DB / EQL Flags: --direct (eql install, requires --supabase) Run the SQL directly against the database (mutually exclusive with --migration) --migrations-dir <path> (eql install, requires --supabase) Override the Supabase migrations directory (default: supabase/migrations) --exclude-operator-family (eql install, eql upgrade, db validate) Skip operator family creation - --latest (eql install, eql upgrade) Fetch the latest EQL from GitHub + --eql-version <2|3> (eql install, eql upgrade) EQL generation to target (default: 2). v3 is the + native eql_v3.* domain schema; direct install only for now + --latest (eql install, eql upgrade) Fetch the latest EQL from GitHub (v2 only) --database-url <url> (all db / eql / schema commands) Override DATABASE_URL for this run only — never written to disk Examples: @@ -229,6 +231,7 @@ async function runInstall( migration: flags.migration, direct: flags.direct, migrationsDir: values['migrations-dir'], + eqlVersion: values['eql-version'], databaseUrl: values['database-url'], }) } @@ -242,6 +245,7 @@ async function runUpgrade( supabase: flags.supabase, excludeOperatorFamily: flags['exclude-operator-family'], latest: flags.latest, + eqlVersion: values['eql-version'], databaseUrl: values['database-url'], }) } diff --git a/packages/cli/src/commands/db/install.ts b/packages/cli/src/commands/db/install.ts index 2e0e82a2..b4c97249 100644 --- a/packages/cli/src/commands/db/install.ts +++ b/packages/cli/src/commands/db/install.ts @@ -65,6 +65,12 @@ export interface InstallOptions { * never persisted. See `src/config/database-url.ts`. */ databaseUrl?: string + /** + * EQL generation to install: `'2'` (default, composite `eql_v2_encrypted`) + * or `'3'` (native `eql_v3.*` domain schema). v3 currently supports the + * direct install path only — not `--drizzle`, `--migration`, or `--latest`. + */ + eqlVersion?: string } /** Resolved install mode for the Supabase non-Drizzle branch. */ @@ -110,7 +116,17 @@ export async function installCommand(options: InstallOptions) { // CIP-2985. const resolved = resolveProviderOptions(options, config.databaseUrl) - if (resolved.drizzle) { + const eqlVersion: 2 | 3 = options.eqlVersion === '3' ? 3 : 2 + + // v3 supports the direct install path only. Explicit --drizzle/--migration + // are rejected up-front by validateInstallFlags; auto-DETECTED drizzle or + // migration modes fall back to direct here rather than erroring. + const routing = routeInstallPathForEqlVersion(eqlVersion, resolved) + if (routing.notice) { + p.log.info(routing.notice) + } + + if (routing.drizzle) { await generateDrizzleMigration(s, { name: options.name, out: options.out, @@ -126,7 +142,8 @@ export async function installCommand(options: InstallOptions) { // running SQL directly. Detection of `supabase/migrations/` only seeds the // prompt default — it never enables `--supabase`. Direct install is the // historical default and remains the fallback when nothing else applies. - if (resolved.supabase) { + // v3 skips the mode selection entirely: direct install only for now. + if (routing.useSupabaseInstallModeSelection) { const projectInfo = detectSupabaseProject( process.cwd(), options.migrationsDir, @@ -159,7 +176,7 @@ export async function installCommand(options: InstallOptions) { p.log.info('Dry run — no changes will be made.') const source = options.latest ? 'Would download EQL install script from GitHub' - : 'Would use bundled EQL install script' + : `Would use bundled EQL${eqlVersion === 3 ? ' v3' : ''} install script` p.note(`${source}\nWould execute the SQL against the database`, 'Dry Run') p.outro('Dry run complete.') return @@ -205,7 +222,7 @@ export async function installCommand(options: InstallOptions) { if (!options.force) { s.start('Checking if EQL is already installed...') - const installed = await installer.isInstalled() + const installed = await installer.isInstalled({ eqlVersion }) s.stop(installed ? 'EQL is already installed.' : 'EQL is not installed.') if (installed) { @@ -216,11 +233,14 @@ export async function installCommand(options: InstallOptions) { } const source = options.latest ? 'from GitHub (latest)' : 'bundled' - s.start(`Installing EQL extensions (${source})...`) + s.start( + `Installing EQL ${eqlVersion === 3 ? 'v3 ' : ''}extensions (${source})...`, + ) await installer.install({ excludeOperatorFamily, supabase: resolved.supabase, latest: options.latest, + eqlVersion, }) s.stop('EQL extensions installed.') @@ -486,11 +506,69 @@ async function generateDrizzleMigration( * * Returns a user-facing error message, or `null` when the flags are valid. */ +/** + * Route the install between the drizzle / supabase-migration / direct paths + * for the requested EQL generation. Pure — no I/O, no prompts — so the v3 + * fallback behaviour is unit-testable. + * + * v3 supports the direct path only: auto-detected drizzle falls back to + * direct with a user-facing notice (explicit `--drizzle`/`--migration` are + * already rejected by {@link validateInstallFlags}), and the Supabase + * migration-vs-direct mode selection is skipped entirely. + */ +export function routeInstallPathForEqlVersion( + eqlVersion: 2 | 3, + resolved: { supabase: boolean; drizzle: boolean }, +): { + drizzle: boolean + useSupabaseInstallModeSelection: boolean + notice?: string +} { + if (eqlVersion === 3) { + return { + drizzle: false, + useSupabaseInstallModeSelection: false, + notice: resolved.drizzle + ? 'EQL v3 does not support the Drizzle migration path yet — installing directly.' + : undefined, + } + } + return { + drizzle: resolved.drizzle, + useSupabaseInstallModeSelection: resolved.supabase, + } +} + export function validateInstallFlags(options: InstallOptions): string | null { if (options.migration && options.direct) { return '`--migration` and `--direct` are mutually exclusive. Pick one.' } + if ( + options.eqlVersion !== undefined && + options.eqlVersion !== '2' && + options.eqlVersion !== '3' + ) { + return `Unknown \`--eql-version ${options.eqlVersion}\`. Supported values: 2, 3.` + } + + if (options.eqlVersion === '3') { + const incompatible = options.drizzle + ? '--drizzle' + : options.migration + ? '--migration' + : options.latest + ? '--latest' + : // --migrations-dir only feeds the Supabase v2 migration-file path; + // the v3 direct install would silently ignore it — reject instead. + options.migrationsDir !== undefined + ? '--migrations-dir' + : null + if (incompatible) { + return `\`--eql-version 3\` does not support \`${incompatible}\` yet — v3 currently installs via the direct path only.` + } + } + const subFlag = options.migration === true ? '--migration' diff --git a/packages/cli/src/commands/db/status.ts b/packages/cli/src/commands/db/status.ts index d22abedc..ebde1596 100644 --- a/packages/cli/src/commands/db/status.ts +++ b/packages/cli/src/commands/db/status.ts @@ -18,15 +18,23 @@ export async function statusCommand(options: { databaseUrl?: string } = {}) { databaseUrl: config.databaseUrl, }) - // 1. Check EQL installation status and version + // 1. Check EQL installation status and version — both generations, so a + // v3-only database is not misreported as "not installed" (the v2 check + // only looks for the eql_v2 schema). s.start('Checking EQL installation...') - let installed: boolean - let version: string | null + let installedV2: boolean + let installedV3: boolean + let versionV2: string | null + let versionV3: string | null try { - installed = await installer.isInstalled() - version = installed ? await installer.getInstalledVersion() : null + installedV2 = await installer.isInstalled() + installedV3 = await installer.isInstalled({ eqlVersion: 3 }) + versionV2 = installedV2 ? await installer.getInstalledVersion() : null + versionV3 = installedV3 + ? await installer.getInstalledVersion({ eqlVersion: 3 }) + : null } catch (error) { s.stop('Failed.') p.log.error( @@ -38,9 +46,18 @@ export async function statusCommand(options: { databaseUrl?: string } = {}) { process.exit(1) } - if (installed) { + if (installedV2 || installedV3) { s.stop('EQL is installed.') - p.log.success(`EQL installed: yes (version: ${version ?? 'unknown'})`) + if (installedV2) { + p.log.success( + `EQL v2 installed: yes (version: ${versionV2 ?? 'unknown'})`, + ) + } + if (installedV3) { + p.log.success( + `EQL v3 installed: yes (version: ${versionV3 ?? 'unknown'})`, + ) + } } else { s.stop('EQL is not installed.') p.log.warn( diff --git a/packages/cli/src/commands/db/upgrade.ts b/packages/cli/src/commands/db/upgrade.ts index 492dddca..8e5db042 100644 --- a/packages/cli/src/commands/db/upgrade.ts +++ b/packages/cli/src/commands/db/upgrade.ts @@ -9,10 +9,33 @@ export async function upgradeCommand(options: { excludeOperatorFamily?: boolean latest?: boolean databaseUrl?: string + /** EQL generation to upgrade: `'2'` (default) or `'3'`. */ + eqlVersion?: string }) { const pm = detectPackageManager() p.intro(runnerCommand(pm, 'stash eql upgrade')) + if ( + options.eqlVersion !== undefined && + options.eqlVersion !== '2' && + options.eqlVersion !== '3' + ) { + p.log.error( + `Unknown \`--eql-version ${options.eqlVersion}\`. Supported values: 2, 3.`, + ) + p.outro('Upgrade aborted.') + process.exit(1) + } + const eqlVersion: 2 | 3 = options.eqlVersion === '3' ? 3 : 2 + + if (eqlVersion === 3 && options.latest) { + p.log.error( + '`--eql-version 3` does not support `--latest` — no public v3 release artifacts exist yet. Use the bundled upgrade.', + ) + p.outro('Upgrade aborted.') + process.exit(1) + } + const s = p.spinner() s.start('Loading stash.config.ts...') @@ -27,18 +50,30 @@ export async function upgradeCommand(options: { }) s.start('Checking current EQL installation...') - const installed = await installer.isInstalled() + const installed = await installer.isInstalled({ eqlVersion }) if (!installed) { - s.stop('EQL is not installed.') - p.log.warn( - `EQL is not currently installed. Run "${runnerCommand(pm, 'stash eql install')}" first.`, - ) + s.stop(`EQL v${eqlVersion} is not installed.`) + // A version mismatch is the likely cause — point at the generation that + // IS installed rather than a bare "run install". + const otherVersion: 2 | 3 = eqlVersion === 3 ? 2 : 3 + const otherInstalled = await installer + .isInstalled({ eqlVersion: otherVersion }) + .catch(() => false) + if (otherInstalled) { + p.log.warn( + `EQL v${eqlVersion} is not installed, but EQL v${otherVersion} is. Re-run with \`--eql-version ${otherVersion}\`, or install v${eqlVersion} with "${runnerCommand(pm, `stash eql install --eql-version ${eqlVersion}`)}".`, + ) + } else { + p.log.warn( + `EQL is not currently installed. Run "${runnerCommand(pm, 'stash eql install')}" first.`, + ) + } p.outro('Upgrade aborted.') process.exit(1) } - const previousVersion = await installer.getInstalledVersion() + const previousVersion = await installer.getInstalledVersion({ eqlVersion }) s.stop(`Current version: ${previousVersion ?? 'unknown'}`) if (options.dryRun) { @@ -55,11 +90,14 @@ export async function upgradeCommand(options: { } const source = options.latest ? 'from GitHub (latest)' : 'bundled' - s.start(`Upgrading EQL extensions (${source})...`) + s.start( + `Upgrading EQL ${eqlVersion === 3 ? 'v3 ' : ''}extensions (${source})...`, + ) await installer.install({ excludeOperatorFamily: options.excludeOperatorFamily, supabase: options.supabase, latest: options.latest, + eqlVersion, }) s.stop('EQL extensions upgraded.') @@ -68,7 +106,7 @@ export async function upgradeCommand(options: { } s.start('Verifying new version...') - const newVersion = await installer.getInstalledVersion() + const newVersion = await installer.getInstalledVersion({ eqlVersion }) s.stop(`New version: ${newVersion ?? 'unknown'}`) if (previousVersion && newVersion && previousVersion === newVersion) { diff --git a/packages/cli/src/installer/index.ts b/packages/cli/src/installer/index.ts index 108b8b4a..5f8158ff 100644 --- a/packages/cli/src/installer/index.ts +++ b/packages/cli/src/installer/index.ts @@ -8,25 +8,59 @@ const EQL_VERSION = 'eql-2.3.1' const EQL_INSTALL_URL = `https://github.com/cipherstash/encrypt-query-language/releases/download/${EQL_VERSION}/cipherstash-encrypt.sql` const EQL_INSTALL_NO_OPERATOR_FAMILY_URL = `https://github.com/cipherstash/encrypt-query-language/releases/download/${EQL_VERSION}/cipherstash-encrypt-supabase.sql` const EQL_SCHEMA_NAME = 'eql_v2' +const EQL_V3_SCHEMA_NAME = 'eql_v3' +const EQL_V3_INTERNAL_SCHEMA_NAME = 'eql_v3_internal' /** - * SQL block that grants the EQL schema, tables, routines, and sequences to - * Supabase's built-in roles (`anon`, `authenticated`, `service_role`). + * Which EQL generation to install / inspect. `2` is the composite + * `eql_v2_encrypted` type; `3` is the native `eql_v3.*` domain schema. + */ +export type EqlVersion = 2 | 3 + +function schemaNameFor(eqlVersion: EqlVersion): string { + return eqlVersion === 3 ? EQL_V3_SCHEMA_NAME : EQL_SCHEMA_NAME +} + +/** + * Build the SQL block that grants an EQL schema, tables, routines, and + * sequences to Supabase's built-in roles (`anon`, `authenticated`, + * `service_role`). * * Supabase uses dedicated roles that don't own the schema, so explicit grants - * are required. We expose this as a single multi-statement string so it can be + * are required. Returned as a single multi-statement string so it can be * executed in one `client.query()` (Postgres accepts multi-statement strings) * AND embedded directly into a Supabase migration file. One source of truth - * for both the runtime install path and the generated migration file. + * for both the runtime install path and the generated migration file, shared + * by the v2 (`eql_v2`) and v3 (`eql_v3`) installs. */ -export const SUPABASE_PERMISSIONS_SQL = `GRANT USAGE ON SCHEMA ${EQL_SCHEMA_NAME} TO anon, authenticated, service_role; -GRANT SELECT ON ALL TABLES IN SCHEMA ${EQL_SCHEMA_NAME} TO anon, authenticated, service_role; -GRANT EXECUTE ON ALL ROUTINES IN SCHEMA ${EQL_SCHEMA_NAME} TO anon, authenticated, service_role; -GRANT USAGE ON ALL SEQUENCES IN SCHEMA ${EQL_SCHEMA_NAME} TO anon, authenticated, service_role; -ALTER DEFAULT PRIVILEGES FOR ROLE postgres IN SCHEMA ${EQL_SCHEMA_NAME} GRANT SELECT ON TABLES TO anon, authenticated, service_role; -ALTER DEFAULT PRIVILEGES FOR ROLE postgres IN SCHEMA ${EQL_SCHEMA_NAME} GRANT EXECUTE ON ROUTINES TO anon, authenticated, service_role; -ALTER DEFAULT PRIVILEGES FOR ROLE postgres IN SCHEMA ${EQL_SCHEMA_NAME} GRANT USAGE ON SEQUENCES TO anon, authenticated, service_role; +export function supabasePermissionsSql(schemaName: string): string { + return `GRANT USAGE ON SCHEMA ${schemaName} TO anon, authenticated, service_role; +GRANT SELECT ON ALL TABLES IN SCHEMA ${schemaName} TO anon, authenticated, service_role; +GRANT EXECUTE ON ALL ROUTINES IN SCHEMA ${schemaName} TO anon, authenticated, service_role; +GRANT USAGE ON ALL SEQUENCES IN SCHEMA ${schemaName} TO anon, authenticated, service_role; +ALTER DEFAULT PRIVILEGES FOR ROLE postgres IN SCHEMA ${schemaName} GRANT SELECT ON TABLES TO anon, authenticated, service_role; +ALTER DEFAULT PRIVILEGES FOR ROLE postgres IN SCHEMA ${schemaName} GRANT EXECUTE ON ROUTINES TO anon, authenticated, service_role; +ALTER DEFAULT PRIVILEGES FOR ROLE postgres IN SCHEMA ${schemaName} GRANT USAGE ON SEQUENCES TO anon, authenticated, service_role; ` +} + +/** The v2 (`eql_v2`) Supabase grants block. See {@link supabasePermissionsSql}. */ +export const SUPABASE_PERMISSIONS_SQL = supabasePermissionsSql(EQL_SCHEMA_NAME) + +/** + * The v3 Supabase grants block: `eql_v3` AND `eql_v3_internal`. The bundle's + * functions are all SECURITY INVOKER (deliberately, so PostgreSQL can inline + * them), and the `eql_v3` operators call into SEM extractors/comparators that + * live in `eql_v3_internal` — so the calling role itself needs USAGE/EXECUTE + * on the internal schema too, or every encrypted query fails `42501`. + * + * Grants ≠ exposure: only `eql_v3` goes in the dashboard's Exposed schemas; + * `eql_v3_internal` must stay unexposed (the split exists so the Supabase + * Table-Builder type picker shows only the column domains). + */ +export const SUPABASE_PERMISSIONS_SQL_V3 = + supabasePermissionsSql(EQL_V3_SCHEMA_NAME) + + supabasePermissionsSql(EQL_V3_INTERNAL_SCHEMA_NAME) /** * Get the directory of the current file, supporting both ESM and CJS. @@ -165,20 +199,32 @@ export class EQLInstaller { } /** - * Check whether the EQL extension is installed by looking for the `eql_v2` schema. + * Check whether the EQL extension is installed by looking for its schema + * (`eql_v2` by default, `eql_v3` when `eqlVersion: 3`). */ - async isInstalled(): Promise<boolean> { + async isInstalled(options?: { eqlVersion?: EqlVersion }): Promise<boolean> { const client = new pg.Client({ connectionString: this.databaseUrl }) + const eqlVersion = options?.eqlVersion ?? 2 try { await client.connect() + // v3 is generation-aware: a pre-alpha.2 install has eql_v3 but no + // eql_v3_internal (and pins v:2 envelopes in its domain CHECKs) — treat + // it as NOT installed so an install run replaces it (the bundle opens by + // dropping both schemas) instead of a stale surface silently accepting + // wrong-generation wire data. + const requiredSchemas = + eqlVersion === 3 + ? [EQL_V3_SCHEMA_NAME, EQL_V3_INTERNAL_SCHEMA_NAME] + : [EQL_SCHEMA_NAME] + const result = await client.query( - 'SELECT schema_name FROM information_schema.schemata WHERE schema_name = $1', - [EQL_SCHEMA_NAME], + 'SELECT count(*)::int AS found FROM information_schema.schemata WHERE schema_name = ANY($1)', + [requiredSchemas], ) - return result.rowCount !== null && result.rowCount > 0 + return result.rows[0]?.found === requiredSchemas.length } catch (error) { const detail = error instanceof Error ? error.message : String(error) throw new Error(`Failed to connect to database: ${detail}`, { @@ -195,7 +241,10 @@ export class EQLInstaller { * This is best-effort: if the schema exists but no version metadata is * available, `'unknown'` is returned. */ - async getInstalledVersion(): Promise<string | null> { + async getInstalledVersion(options?: { + eqlVersion?: EqlVersion + }): Promise<string | null> { + const schemaName = schemaNameFor(options?.eqlVersion ?? 2) const client = new pg.Client({ connectionString: this.databaseUrl }) try { @@ -203,7 +252,7 @@ export class EQLInstaller { const schemaResult = await client.query( 'SELECT schema_name FROM information_schema.schemata WHERE schema_name = $1', - [EQL_SCHEMA_NAME], + [schemaName], ) if (schemaResult.rowCount === null || schemaResult.rowCount === 0) { @@ -215,7 +264,7 @@ export class EQLInstaller { // we fall back to 'unknown'. try { const versionResult = await client.query( - `SELECT ${EQL_SCHEMA_NAME}.version() AS version`, + `SELECT ${schemaName}.version() AS version`, ) if (versionResult.rows.length > 0 && versionResult.rows[0].version) { @@ -249,12 +298,26 @@ export class EQLInstaller { excludeOperatorFamily?: boolean supabase?: boolean latest?: boolean + eqlVersion?: EqlVersion }): Promise<void> { - const { supabase = false, latest = false } = options ?? {} + const { supabase = false, latest = false, eqlVersion = 2 } = options ?? {} const excludeOperatorFamily = options?.excludeOperatorFamily || supabase + + if (latest && eqlVersion === 3) { + // No public v3 release artifacts exist yet — the v3 bundles are vendored + // from the generated monolith (see scripts/build-eql-v3-sql.mjs). + throw new Error( + '`--latest` is not supported for EQL v3 yet: no public v3 release artifacts exist. Use the bundled install.', + ) + } + const sql = latest ? await this.downloadInstallScript(excludeOperatorFamily) - : this.loadBundledInstallScript({ excludeOperatorFamily, supabase }) + : this.loadBundledInstallScript({ + excludeOperatorFamily, + supabase, + eqlVersion, + }) const client = new pg.Client({ connectionString: this.databaseUrl }) @@ -272,7 +335,7 @@ export class EQLInstaller { await client.query(sql) if (supabase) { - await this.grantSupabasePermissions(client) + await this.grantSupabasePermissions(client, eqlVersion) } await client.query('COMMIT') @@ -291,16 +354,25 @@ export class EQLInstaller { } /** - * Grant Supabase roles access to the eql_v2 schema. + * Grant Supabase roles access to the installed EQL schema. * * Supabase uses dedicated roles (anon, authenticated, service_role) that - * don't own the schema, so explicit grants are required. Issues - * {@link SUPABASE_PERMISSIONS_SQL} as a single multi-statement query — + * don't own the schema, so explicit grants are required. Issues the + * {@link supabasePermissionsSql} block as a single multi-statement query — * Postgres accepts that and it keeps the SQL identical to what we'd write * into a Supabase migration file. */ - private async grantSupabasePermissions(client: pg.Client): Promise<void> { - await client.query(SUPABASE_PERMISSIONS_SQL) + private async grantSupabasePermissions( + client: pg.Client, + eqlVersion: EqlVersion, + ): Promise<void> { + // v3 grants cover eql_v3 AND eql_v3_internal (SECURITY INVOKER functions + // in the internal schema back the eql_v3 operators). + await client.query( + eqlVersion === 3 + ? SUPABASE_PERMISSIONS_SQL_V3 + : supabasePermissionsSql(schemaNameFor(eqlVersion)), + ) } /** @@ -309,6 +381,7 @@ export class EQLInstaller { private loadBundledInstallScript(options: { excludeOperatorFamily: boolean supabase: boolean + eqlVersion: EqlVersion }): string { const filename = resolveBundledFilename(options) @@ -358,11 +431,21 @@ export class EQLInstaller { * - `supabase: true` → Supabase-specific variant * - `excludeOperatorFamily: true` → no operator family variant * - default → standard install + * + * For EQL v3 the Supabase variant IS the no-operator-family variant (the v3 + * bundle's only superuser-requiring statements are its two operator-class + * chunks), so both flags resolve to the same file. */ function resolveBundledFilename(options: { excludeOperatorFamily: boolean supabase: boolean + eqlVersion?: EqlVersion }): string { + if ((options.eqlVersion ?? 2) === 3) { + if (options.supabase || options.excludeOperatorFamily) + return 'cipherstash-encrypt-v3-supabase.sql' + return 'cipherstash-encrypt-v3.sql' + } if (options.supabase) return 'cipherstash-encrypt-supabase.sql' if (options.excludeOperatorFamily) return 'cipherstash-encrypt-no-operator-family.sql' @@ -373,11 +456,16 @@ function resolveBundledFilename(options: { * Load the bundled EQL install SQL. Used by the Drizzle migration path. */ export function loadBundledEqlSql( - options: { excludeOperatorFamily?: boolean; supabase?: boolean } = {}, + options: { + excludeOperatorFamily?: boolean + supabase?: boolean + eqlVersion?: EqlVersion + } = {}, ): string { const filename = resolveBundledFilename({ excludeOperatorFamily: options.excludeOperatorFamily ?? false, supabase: options.supabase ?? false, + eqlVersion: options.eqlVersion ?? 2, }) try { diff --git a/packages/cli/src/sql/cipherstash-encrypt-v3-supabase.sql b/packages/cli/src/sql/cipherstash-encrypt-v3-supabase.sql new file mode 100644 index 00000000..45f11bc8 --- /dev/null +++ b/packages/cli/src/sql/cipherstash-encrypt-v3-supabase.sql @@ -0,0 +1,36229 @@ +--! @file v3/schema.sql +--! @brief EQL v3 schema creation +--! +--! Creates the eql_v3 and eql_v3_internal schemas. eql_v3 is the public API: +--! the self-contained encrypted-domain type families (eql_v3.integer, eql_v3.bigint, +--! and future scalar domains) — their jsonb-backed domains, index-term +--! extractors, aggregates, AND the operator-backing comparison wrappers +--! (eq/neq/lt/lte/gt/gte/contains/contained_by, plus the jsonb containment +--! helpers). The wrappers are public because they are the function-form +--! equivalent of every supported operator: platforms without operator support +--! (Supabase/PostgREST calls functions, not operators) invoke them by name. +--! eql_v3_internal houses INTERNAL implementation objects only: the +--! searchable-encrypted-metadata (SEM) index-term types +--! (eql_v3_internal.hmac_256, eql_v3_internal.ore_block_256) and their support +--! functions, the unsupported-operator blockers (which only raise), and the +--! aggregate state functions. Together the two schemas are self-contained — +--! they own every type they need and have no runtime dependency on another EQL +--! schema. +--! +--! Drops existing schema if present to support clean reinstallation. +--! +--! @warning DROP SCHEMA CASCADE will remove all objects in the schema +--! @note eql_v3 is a new, additional schema for the encrypted-domain families. +--! +--! @note DESIGN DECISION — EQL never grants permissions automatically. This +--! installer issues no GRANT (or REVOKE) on eql_v3 or eql_v3_internal: +--! access is strictly opt-in. A deployment that exposes EQL to +--! non-owner roles (e.g. Supabase `authenticated`/`anon` via PostgREST) +--! must explicitly `GRANT USAGE ON SCHEMA eql_v3` and `GRANT EXECUTE` on +--! the functions it needs. This is intentional least-privilege, not an +--! oversight — see docs/reference/permissions.md. eql_v3_internal is not +--! part of the public API and normally needs no grant; where a caller +--! reaches an internal object indirectly (a public operator/aggregate +--! whose backing state-fn/blocker lives there), grant it deliberately. + +--! @brief Drop existing EQL v3 schema +--! @warning CASCADE will drop all dependent objects +DROP SCHEMA IF EXISTS eql_v3 CASCADE; + +--! @brief Create EQL v3 schema +--! @note Houses the encrypted-domain type families +CREATE SCHEMA eql_v3; + +--! @brief Drop existing EQL v3 internal schema +--! @warning CASCADE will drop all dependent objects +DROP SCHEMA IF EXISTS eql_v3_internal CASCADE; + +--! @brief Create EQL v3 internal implementation schema +--! @note Houses INTERNAL eql_v3 objects only: SEM index-term TYPES + their +--! support/constructor/comparator functions, the unsupported-operator +--! blockers (which only raise), the aggregate state functions, and the +--! SteVec CHECK validators. Kept out of the public `eql_v3` surface so +--! internal index-term TYPES do not clutter the Supabase Table Builder +--! type picker. NOTE: the operator-backing comparison *wrappers* are NOT +--! here — they are public in `eql_v3` so every operator has a callable +--! function equivalent for platforms without operator support. +CREATE SCHEMA eql_v3_internal; +COMMENT ON SCHEMA eql_v3_internal IS + 'EQL internal implementation detail; not a public API surface.'; + +--! @brief Schemas owned by the eql_v3 surface +--! +--! Single source of truth for tooling that must enumerate every schema this +--! installer owns (`eql_v3.lints()`, `tasks/pin_search_path_v3.sql`), so a +--! future third eql_v3-family schema is one array literal to edit instead of +--! a hardcoded schema-name predicate repeated at every call site. Keep in +--! sync with the `SCHEMA` / `INTERNAL_SCHEMA` constants in +--! `crates/eql-codegen/src/consts.rs` — those drive what codegen emits into +--! each schema; this drives what tooling scans across both. +--! +--! @return name[] The schema names eql_v3 owns (public + internal). +CREATE FUNCTION eql_v3_internal.owned_schemas() + RETURNS name[] + LANGUAGE sql IMMUTABLE PARALLEL SAFE +AS $$ + SELECT ARRAY['eql_v3', 'eql_v3_internal']::name[] +$$; + +--! @file v3/crypto.sql +--! @brief PostgreSQL pgcrypto extension enablement (eql_v3 fork) +--! +--! Forked from src/crypto.sql (design D8) so the entire eql_v3 dependency +--! closure lives under src/v3/. Enables the pgcrypto extension which provides +--! cryptographic functions used by the eql_v3 ORE comparison path. +--! +--! Installs pgcrypto into the `extensions` schema (Supabase convention) to +--! avoid the `extension_in_public` lint. Every EQL function that uses pgcrypto +--! has `pg_catalog, extensions, public` on its `search_path`, so a pre-existing +--! install in `public` keeps working — and a pre-existing install anywhere else +--! will be rejected at install time. The body is idempotent +--! (`CREATE SCHEMA IF NOT EXISTS`, `pg_extension` guard), so running it +--! alongside the eql_v2 copy in a combined install is safe. +--! +--! @note pgcrypto provides functions like digest(), hmac(), gen_random_bytes() + +--! @brief Create extensions schema (Supabase convention) +CREATE SCHEMA IF NOT EXISTS extensions; + +--! @brief Enable pgcrypto extension and validate its schema +DO $$ +DECLARE + pgcrypto_schema name; +BEGIN + IF NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'pgcrypto') THEN + CREATE EXTENSION pgcrypto WITH SCHEMA extensions; + END IF; + + SELECT n.nspname INTO pgcrypto_schema + FROM pg_extension e + JOIN pg_namespace n ON n.oid = e.extnamespace + WHERE e.extname = 'pgcrypto'; + + IF pgcrypto_schema = 'extensions' THEN + -- expected location, nothing to say + NULL; + ELSIF pgcrypto_schema = 'public' THEN + RAISE NOTICE + 'pgcrypto is installed in the `public` schema. EQL works against this layout, ' + 'but Supabase splinter will flag it as `extension_in_public`. Move it with: ' + 'ALTER EXTENSION pgcrypto SET SCHEMA extensions'; + ELSE + RAISE EXCEPTION + 'pgcrypto is installed in schema `%`, which is not on the EQL function search_path ' + '(pg_catalog, extensions, public). EQL cryptographic operations would fail at ' + 'runtime. Relocate the extension before installing EQL: ' + 'ALTER EXTENSION pgcrypto SET SCHEMA extensions', + pgcrypto_schema; + END IF; +END $$; + +--! @file v3/common.sql +--! @brief Common utility functions for the self-contained eql_v3 surface. +--! +--! Forked from src/common.sql (design D7) so the eql_v3 ORE constructor owns the +--! one transitive helper it needs without reaching into another schema. The +--! eql_v2 original is unchanged. + +--! @brief Convert JSONB hex array to bytea array +--! @internal +--! +--! Converts a JSONB array of hex-encoded strings into a PostgreSQL bytea array. +--! Used for deserializing binary data (like ORE terms) from JSONB storage. +--! +--! @param val jsonb JSONB array of hex-encoded strings +--! @return bytea[] Array of decoded binary values +--! +--! @note Returns NULL if input is JSON null +--! @note Each array element is hex-decoded to bytea +--! @note Inlinable `LANGUAGE sql` IMMUTABLE form (no `SET search_path`) so the +--! planner can fold this per-encrypted-value helper into the calling query. +--! This deliberately diverges from the v2 plpgsql equivalent (intentionally +--! left unchanged): the `CASE WHEN jsonb_typeof(val) = 'array'` guard only +--! evaluates the set-returning `jsonb_array_elements_text` for an array, so a +--! non-array JSON scalar returns NULL here instead of raising "cannot extract +--! elements from a scalar". Both callers only ever pass an array or JSON null +--! (`val->'ob'`), so the divergence is unreachable in practice; JSON null and +--! empty array still return NULL exactly as before. +CREATE FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(val jsonb) +RETURNS bytea[] + IMMUTABLE +AS $$ + SELECT CASE WHEN jsonb_typeof(val) = 'array' + THEN ( + SELECT array_agg(decode(value::text, 'hex')::bytea) + FROM jsonb_array_elements_text(val) AS value + ) + ELSE NULL + END; +$$ LANGUAGE sql; + +--! @internal Mark this hand-written helper inline-critical so the post-install +--! pin_search_path pass leaves it unpinned (no `SET search_path`), preserving +--! SQL-function inlining. It takes a bare `jsonb` arg (not a jsonb-backed +--! encrypted DOMAIN), so the structural skip in tasks/pin_search_path_v3.sql does +--! not recognise it; this marker is the documented manual opt-in. +COMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(jsonb) IS + 'eql-inline-critical: per-encrypted-value ORE helper; must stay inlinable (unpinned search_path)'; + +--! @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/sem/ore_block_256/functions.sql +--! @brief ORE block construction, extraction, and comparison (eql_v3 SEM). +--! +--! jsonb-only subset of src/ore_block_u64_8_256/functions.sql. The +--! encrypted-column overloads are omitted; the helper jsonb_array_to_bytea_array +--! and pgcrypto encrypt() are reached via the forked src/v3/common.sql and +--! src/v3/crypto.sql so the whole closure stays under src/v3. (Doc comments +--! deliberately avoid naming eql_v2 symbols so the self-containment grep stays +--! clean.) + +--! @brief Convert JSONB array to ORE block composite type +--! @internal +--! @param val jsonb Array of hex-encoded ORE block terms +--! @return eql_v3_internal.ore_block_256 ORE block composite, or NULL if input is null +--! @note Inlinable `LANGUAGE sql` IMMUTABLE form (no `SET search_path`) so the +--! planner can fold this per-encrypted-value helper into the calling query. +--! This deliberately diverges from the v2 plpgsql equivalent (intentionally +--! left unchanged): the `CASE WHEN jsonb_typeof(val) = 'array'` guard only +--! evaluates the array path for an array, so a non-array JSON scalar returns +--! NULL here instead of raising. The sole caller (`ore_block_256`) only reaches +--! this when `has_ore_block_256(val)` is true, which now requires `val->'ob'` +--! to be a JSON array, so the non-array branch is unreachable in practice. +--! An empty array (`ob: []`, what encrypting the empty string `""` produces) +--! yields a non-NULL composite with an EMPTY `terms` array — NOT NULL terms. +--! The `COALESCE` is load-bearing: `array_agg` over zero rows returns NULL, and +--! NULL terms make the comparator return NULL (so an empty-text row silently +--! drops out of ordered queries). An empty array instead engages the +--! comparator's `cardinality = 0` guard, which sorts empty BEFORE every +--! non-empty term. See issue #262 (pinned by T7). +CREATE FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(val jsonb) +RETURNS eql_v3_internal.ore_block_256 + IMMUTABLE +AS $$ + SELECT CASE WHEN jsonb_typeof(val) = 'array' + THEN ROW(COALESCE( + ( + SELECT array_agg(ROW(b)::eql_v3_internal.ore_block_256_term) + FROM unnest(eql_v3_internal.jsonb_array_to_bytea_array(val)) AS b + ), + ARRAY[]::eql_v3_internal.ore_block_256_term[] + ))::eql_v3_internal.ore_block_256 + ELSE NULL + END; +$$ LANGUAGE sql; + +--! @internal Mark this hand-written helper inline-critical so the post-install +--! pin_search_path pass leaves it unpinned (no `SET search_path`), preserving +--! SQL-function inlining. It takes a bare `jsonb` arg (not a jsonb-backed +--! encrypted DOMAIN), so the structural skip in tasks/pin_search_path_v3.sql does +--! not recognise it; this marker is the documented manual opt-in. +COMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(jsonb) IS + 'eql-inline-critical: per-encrypted-value ORE helper; must stay inlinable (unpinned search_path)'; + + +--! @brief Extract ORE block index term from JSONB payload +--! @param val jsonb containing encrypted EQL payload +--! @return eql_v3_internal.ore_block_256 ORE block index term +--! @throws Exception if 'ob' field is missing +CREATE FUNCTION eql_v3_internal.ore_block_256(val jsonb) + RETURNS eql_v3_internal.ore_block_256 + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + BEGIN + -- Declared STRICT: PostgreSQL returns NULL for a NULL argument without + -- entering the body, so no explicit `val IS NULL` guard is needed. + IF eql_v3_internal.has_ore_block_256(val) THEN + RETURN eql_v3_internal.jsonb_array_to_ore_block_256(val->'ob'); + END IF; + RAISE 'Expected an ore index (ob) value in json: %', val; + END; +$$ LANGUAGE plpgsql; + + +--! @brief Check if JSONB payload contains an ORE block index term +--! @param val jsonb containing encrypted EQL payload +--! @return boolean True only if the 'ob' field is present and is a JSON array +--! @note A well-formed ORE index term is always a JSON array of block terms, so +--! this guard treats a present-but-non-array `ob` (a scalar or object) as +--! absent. That makes the extractor `ore_block_256(val)` RAISE on a +--! structurally invalid `ob` payload at the boundary instead of silently +--! degrading it to a NULL index term in `jsonb_array_to_ore_block_256`. The +--! previous `val ->> 'ob' IS NOT NULL` form stringified scalars/objects and so +--! reported them as present. `{}` (absent `ob`) and `{"ob": null}` (JSON null) +--! both remain `false`. +CREATE FUNCTION eql_v3_internal.has_ore_block_256(val jsonb) + RETURNS boolean + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + BEGIN + RETURN COALESCE(jsonb_typeof(val -> 'ob') = 'array', false); + END; +$$ LANGUAGE plpgsql; + + +--! @brief Compare two ORE block terms using cryptographic comparison +--! @internal +--! @param a eql_v3_internal.ore_block_256_term First ORE term +--! @param b eql_v3_internal.ore_block_256_term Second ORE term +--! @return integer -1 if a < b, 0 if a = b, 1 if a > b +--! @throws Exception if ciphertexts are different lengths +--! @note Marked `IMMUTABLE` (the three `compare_ore_block_256_term(s)` +--! overloads all are). This deliberately diverges from the v2 originals, +--! which carry no volatility marker and so default to `VOLATILE`. The +--! comparison is deterministic — its only crypto call, pgcrypto `encrypt()`, +--! is itself `IMMUTABLE STRICT PARALLEL SAFE` — so `IMMUTABLE` lets the +--! planner fold/cache these in ordering and index contexts. NOT `STRICT`: +--! the NULL-handling branches below are load-bearing for the array overload. +CREATE FUNCTION eql_v3_internal.compare_ore_block_256_term(a eql_v3_internal.ore_block_256_term, b eql_v3_internal.ore_block_256_term) + RETURNS integer + IMMUTABLE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + eq boolean := true; + unequal_block smallint := 0; + hash_key bytea; + data_block bytea; + encrypt_block bytea; + target_block bytea; + + left_block_size CONSTANT smallint := 16; + right_block_size CONSTANT smallint := 32; + + -- Block count N is DERIVED from the ciphertext length, not hardcoded to 8. + -- Wire format per term: + -- [ N PRP bytes ][ N*16B left blocks ][ 16B hash key ][ N*32B right blocks ] + -- octet_length = 17*N + 16 + 32*N = 49*N + 16 => N = (octet_length - 16) / 49 + -- This serves integer (N=8, 408B), timestamp (N=12, 604B), and numeric + -- (N=14, 702B) with one comparator. + n integer; + left_offset integer; -- ordinal offset of the first left block (1 + N PRP bytes) + right_offset integer; -- ordinal start of the right CT (= total left CT length = 17*N) + + indicator smallint := 0; + BEGIN + IF a IS NULL AND b IS NULL THEN + RETURN 0; + END IF; + + IF a IS NULL THEN + RETURN -1; + END IF; + + IF b IS NULL THEN + RETURN 1; + END IF; + + IF bit_length(a.bytes) != bit_length(b.bytes) THEN + RAISE EXCEPTION 'Ciphertexts are different lengths'; + END IF; + + -- Well-formedness: length must be exactly 49*N + 16 for some N >= 1. The + -- modulo alone is insufficient -- a 16-byte term passes (16 - 16) % 49 = 0 + -- and derives N = 0, which would fall through to the all-blocks-equal path + -- and return 0 instead of raising. The `<= 16` clause is load-bearing. + IF octet_length(a.bytes) <= 16 OR (octet_length(a.bytes) - 16) % 49 != 0 THEN + RAISE EXCEPTION 'Malformed ORE term: % bytes', octet_length(a.bytes); + END IF; + + n := (octet_length(a.bytes) - 16) / 49; + left_offset := 1 + n; -- left blocks begin right after the N PRP bytes + right_offset := 17 * n; -- right CT begins right after the 17*N-byte left CT + + FOR block IN 0..n-1 LOOP + -- Compare each PRP byte (the first N bytes) and its 16-byte left block. + IF + substr(a.bytes, 1 + block, 1) != substr(b.bytes, 1 + block, 1) + OR substr(a.bytes, left_offset + left_block_size * block, left_block_size) != substr(b.bytes, left_offset + left_block_size * block, left_block_size) + THEN + IF eq THEN + unequal_block := block; + END IF; + eq = false; + END IF; + END LOOP; + + IF eq THEN + RETURN 0::integer; + END IF; + + -- Hash key is the IV from the right CT of b. + hash_key := substr(b.bytes, right_offset + 1, 16); + + -- First right block is at right_offset + nonce_size (ordinally indexed). + target_block := substr(b.bytes, right_offset + 17 + (unequal_block * right_block_size), right_block_size); + + data_block := substr(a.bytes, left_offset + (left_block_size * unequal_block), left_block_size); + + encrypt_block := encrypt(data_block::bytea, hash_key::bytea, 'aes-ecb'); + + indicator := ( + get_bit( + encrypt_block, + 0 + ) + get_bit(target_block, get_byte(a.bytes, unequal_block))) % 2; + + IF indicator = 1 THEN + RETURN 1::integer; + ELSE + RETURN -1::integer; + END IF; + END; +$$ LANGUAGE plpgsql; + + +--! @brief Compare arrays of ORE block terms recursively +--! @internal +--! @param a eql_v3_internal.ore_block_256_term[] First array +--! @param b eql_v3_internal.ore_block_256_term[] Second array +--! @return integer -1/0/1, or NULL if either array is NULL +CREATE FUNCTION eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256_term[], b eql_v3_internal.ore_block_256_term[]) +RETURNS integer + IMMUTABLE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + cmp_result integer; + BEGIN + IF a IS NULL OR b IS NULL THEN + RETURN NULL; + END IF; + + IF cardinality(a) = 0 AND cardinality(b) = 0 THEN + RETURN 0; + END IF; + + IF (cardinality(a) = 0) AND cardinality(b) > 0 THEN + RETURN -1; + END IF; + + IF cardinality(a) > 0 AND (cardinality(b) = 0) THEN + RETURN 1; + END IF; + + cmp_result := eql_v3_internal.compare_ore_block_256_term(a[1], b[1]); + + IF cmp_result = 0 THEN + RETURN eql_v3_internal.compare_ore_block_256_terms(a[2:array_length(a,1)], b[2:array_length(b,1)]); + END IF; + + RETURN cmp_result; + END +$$ LANGUAGE plpgsql; + + +--! @brief Compare ORE block composite types +--! @internal +--! @param a eql_v3_internal.ore_block_256 First ORE block +--! @param b eql_v3_internal.ore_block_256 Second ORE block +--! @return integer -1/0/1 +CREATE FUNCTION eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) +RETURNS integer + IMMUTABLE + SET search_path = pg_catalog, extensions, public +AS $$ + BEGIN + RETURN eql_v3_internal.compare_ore_block_256_terms(a.terms, b.terms); + 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_ope_term(col)` engages structurally for the `_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[]; + +--! @file v3/sem/ore_cllw/types.sql +--! @brief CLLW ORE index term type for STE-vec range queries (eql_v3 SEM) +--! +--! Composite type for CLLW (Copyless Logarithmic Width) Order-Revealing +--! Encryption. The ciphertext is stored in the `oc` field of encrypted data +--! payloads (Standard-mode `ste_vec` elements). Used by the range operators +--! (`<`, `<=`, `>`, `>=`) when an sv element carries an `oc` term. +--! +--! The wire-format `oc` value is a hex string with a leading domain-tag byte +--! (`0x00` numeric, `0x01` string) followed by the CLLW ciphertext. The +--! decoded `bytes` field carries the full byte string including the tag — the +--! comparator is variable-length capable, so numeric and string values within +--! the same column order correctly: the domain tag separates the ranges +--! (numeric < string) and the within-domain comparison falls through to the +--! CLLW per-byte protocol. +--! +--! @note This is a transient type used only during query execution. +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE TYPE eql_v3_internal.ore_cllw AS ( + bytes bytea +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/timestamp/timestamp_types.sql +--! @brief Encrypted-domain types for timestamp. + +DO $$ +BEGIN + --! @brief Encrypted domain eql_v3.timestamp. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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; + + --! @brief Encrypted domain eql_v3.timestamp_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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; + + --! @brief Encrypted domain eql_v3.timestamp_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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; + + --! @brief Encrypted domain eql_v3.timestamp_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.timestamp_ord 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; + + --! @brief Encrypted domain eql_v3.timestamp_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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; +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/<T>/. +--! 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.<T>*) +--! @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.<T>*) +--! @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.<T>*) +--! @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. +--! +--! The six backing functions are inlinable single-statement SQL so the planner +--! can fold the eql_v3 comparison wrappers through to functional-index matching. + +--! @brief Equality backing function for ORE block types +--! @internal +--! +--! @param a eql_v3_internal.ore_block_256 Left operand +--! @param b eql_v3_internal.ore_block_256 Right operand +--! @return boolean True if the ORE blocks are equal +--! +--! @see eql_v3_internal.compare_ore_block_256_terms +CREATE FUNCTION eql_v3_internal.ore_block_256_eq(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) +RETURNS boolean + LANGUAGE sql + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = 0 +$$; + +--! @brief Not-equal backing function for ORE block types +--! @internal +--! +--! @param a eql_v3_internal.ore_block_256 Left operand +--! @param b eql_v3_internal.ore_block_256 Right operand +--! @return boolean True if the ORE blocks are not equal +--! +--! @see eql_v3_internal.compare_ore_block_256_terms +CREATE FUNCTION eql_v3_internal.ore_block_256_neq(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) +RETURNS boolean + LANGUAGE sql + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) <> 0 +$$; + +--! @brief Less-than backing function for ORE block types +--! @internal +--! +--! @param a eql_v3_internal.ore_block_256 Left operand +--! @param b eql_v3_internal.ore_block_256 Right operand +--! @return boolean True if the left operand is less than the right operand +--! +--! @see eql_v3_internal.compare_ore_block_256_terms +CREATE FUNCTION eql_v3_internal.ore_block_256_lt(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) +RETURNS boolean + LANGUAGE sql + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = -1 +$$; + +--! @brief Less-than-or-equal backing function for ORE block types +--! @internal +--! +--! @param a eql_v3_internal.ore_block_256 Left operand +--! @param b eql_v3_internal.ore_block_256 Right operand +--! @return boolean True if the left operand is less than or equal to the right operand +--! +--! @see eql_v3_internal.compare_ore_block_256_terms +CREATE FUNCTION eql_v3_internal.ore_block_256_lte(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) +RETURNS boolean + LANGUAGE sql + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) != 1 +$$; + +--! @brief Greater-than backing function for ORE block types +--! @internal +--! +--! @param a eql_v3_internal.ore_block_256 Left operand +--! @param b eql_v3_internal.ore_block_256 Right operand +--! @return boolean True if the left operand is greater than the right operand +--! +--! @see eql_v3_internal.compare_ore_block_256_terms +CREATE FUNCTION eql_v3_internal.ore_block_256_gt(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) +RETURNS boolean + LANGUAGE sql + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = 1 +$$; + +--! @brief Greater-than-or-equal backing function for ORE block types +--! @internal +--! +--! @param a eql_v3_internal.ore_block_256 Left operand +--! @param b eql_v3_internal.ore_block_256 Right operand +--! @return boolean True if the left operand is greater than or equal to the right operand +--! +--! @see eql_v3_internal.compare_ore_block_256_terms +CREATE FUNCTION eql_v3_internal.ore_block_256_gte(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) +RETURNS boolean + LANGUAGE sql + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) != -1 +$$; + + +--! @brief = operator for ORE block types +--! +--! COMMUTATOR is the operator itself: equality is symmetric. Required for the +--! MERGES flag — without it the planner raises "could not find commutator" the +--! first time an ore_block equality is used as a join qual (e.g. via the inlined +--! eql_v3_internal.<T>_ord_ore equality wrappers). +CREATE OPERATOR public.= ( + FUNCTION=eql_v3_internal.ore_block_256_eq, + LEFTARG=eql_v3_internal.ore_block_256, + RIGHTARG=eql_v3_internal.ore_block_256, + COMMUTATOR = OPERATOR(public.=), + NEGATOR = OPERATOR(public.<>), + RESTRICT = eqsel, + JOIN = eqjoinsel, + HASHES, + MERGES +); + +--! @brief <> operator for ORE block types +CREATE OPERATOR public.<> ( + FUNCTION=eql_v3_internal.ore_block_256_neq, + LEFTARG=eql_v3_internal.ore_block_256, + RIGHTARG=eql_v3_internal.ore_block_256, + COMMUTATOR = OPERATOR(public.<>), + NEGATOR = OPERATOR(public.=), + RESTRICT = neqsel, + JOIN = neqjoinsel, + MERGES +); + +--! @brief > operator for ORE block types +CREATE OPERATOR public.> ( + FUNCTION=eql_v3_internal.ore_block_256_gt, + LEFTARG=eql_v3_internal.ore_block_256, + RIGHTARG=eql_v3_internal.ore_block_256, + COMMUTATOR = OPERATOR(public.<), + NEGATOR = OPERATOR(public.<=), + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel +); + +--! @brief < operator for ORE block types +CREATE OPERATOR public.< ( + FUNCTION=eql_v3_internal.ore_block_256_lt, + LEFTARG=eql_v3_internal.ore_block_256, + RIGHTARG=eql_v3_internal.ore_block_256, + COMMUTATOR = OPERATOR(public.>), + NEGATOR = OPERATOR(public.>=), + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel +); + +--! @brief <= operator for ORE block types +CREATE OPERATOR public.<= ( + FUNCTION=eql_v3_internal.ore_block_256_lte, + LEFTARG=eql_v3_internal.ore_block_256, + RIGHTARG=eql_v3_internal.ore_block_256, + COMMUTATOR = OPERATOR(public.>=), + NEGATOR = OPERATOR(public.>), + RESTRICT = scalarlesel, + JOIN = scalarlejoinsel +); + +--! @brief >= operator for ORE block types +CREATE OPERATOR public.>= ( + FUNCTION=eql_v3_internal.ore_block_256_gte, + LEFTARG=eql_v3_internal.ore_block_256, + RIGHTARG=eql_v3_internal.ore_block_256, + COMMUTATOR = OPERATOR(public.<=), + NEGATOR = 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_ope_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)'; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/text/text_types.sql +--! @brief Encrypted-domain types for text. + +DO $$ +BEGIN + --! @brief Encrypted domain eql_v3.text. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.text AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + --! @brief Encrypted domain eql_v3.text_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.text_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; + + --! @brief Encrypted domain eql_v3.text_match. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_match' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.text_match AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'bf' + AND VALUE->>'v' = '3' + ); + END IF; + + --! @brief Encrypted domain eql_v3.text_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.text_ord_ore 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->>'v' = '3' + ); + END IF; + + --! @brief Encrypted domain eql_v3.text_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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 ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + --! @brief Encrypted domain eql_v3.text_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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; + + --! @brief Encrypted domain eql_v3.text_search. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_search' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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 ? 'ob' + AND VALUE ? 'bf' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; +END +$$; + +--! @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 +$$; + +--! @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 v3/scalars/smallint/smallint_types.sql +--! @brief Encrypted-domain types for smallint. + +DO $$ +BEGIN + --! @brief Encrypted domain eql_v3.smallint. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.smallint AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + --! @brief Encrypted domain eql_v3.smallint_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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; + + --! @brief Encrypted domain eql_v3.smallint_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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 jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + --! @brief Encrypted domain eql_v3.smallint_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.smallint_ord 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; + + --! @brief Encrypted domain eql_v3.smallint_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.smallint_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; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/real/real_types.sql +--! @brief Encrypted-domain types for real. + +DO $$ +BEGIN + --! @brief Encrypted domain eql_v3.real. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.real AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + --! @brief Encrypted domain eql_v3.real_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.real_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; + + --! @brief Encrypted domain eql_v3.real_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.real_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; + + --! @brief Encrypted domain eql_v3.real_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.real_ord 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; + + --! @brief Encrypted domain eql_v3.real_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.real_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; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/numeric/numeric_types.sql +--! @brief Encrypted-domain types for numeric. + +DO $$ +BEGIN + --! @brief Encrypted domain eql_v3.numeric. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.numeric AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + --! @brief Encrypted domain eql_v3.numeric_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.numeric_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; + + --! @brief Encrypted domain eql_v3.numeric_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.numeric_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; + + --! @brief Encrypted domain eql_v3.numeric_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.numeric_ord 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; + + --! @brief Encrypted domain eql_v3.numeric_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.numeric_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; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/integer/integer_types.sql +--! @brief Encrypted-domain types for integer. + +DO $$ +BEGIN + --! @brief Encrypted domain eql_v3.integer. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.integer AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + --! @brief Encrypted domain eql_v3.integer_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.integer_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; + + --! @brief Encrypted domain eql_v3.integer_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.integer_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; + + --! @brief Encrypted domain eql_v3.integer_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.integer_ord 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; + + --! @brief Encrypted domain eql_v3.integer_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.integer_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; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/double/double_types.sql +--! @brief Encrypted-domain types for double. + +DO $$ +BEGIN + --! @brief Encrypted domain eql_v3.double. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.double AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + --! @brief Encrypted domain eql_v3.double_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.double_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; + + --! @brief Encrypted domain eql_v3.double_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.double_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; + + --! @brief Encrypted domain eql_v3.double_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.double_ord 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; + + --! @brief Encrypted domain eql_v3.double_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.double_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; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/date/date_types.sql +--! @brief Encrypted-domain types for date. + +DO $$ +BEGIN + --! @brief Encrypted domain eql_v3.date. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.date AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + --! @brief Encrypted domain eql_v3.date_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.date_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; + + --! @brief Encrypted domain eql_v3.date_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.date_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; + + --! @brief Encrypted domain eql_v3.date_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.date_ord 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; + + --! @brief Encrypted domain eql_v3.date_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.date_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; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/bigint/bigint_types.sql +--! @brief Encrypted-domain types for bigint. + +DO $$ +BEGIN + --! @brief Encrypted domain eql_v3.bigint. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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 Encrypted domain eql_v3.bigint_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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; + + --! @brief Encrypted domain eql_v3.bigint_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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; + + --! @brief Encrypted domain eql_v3.bigint_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.bigint_ord 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; + + --! @brief Encrypted domain eql_v3.bigint_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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; +END +$$; + +--! @file v3/sem/ore_cllw/functions.sql +--! @brief CLLW ORE index-term extraction and comparison (eql_v3 SEM). + +--! @brief Extract CLLW ORE index term from raw jsonb +--! +--! Returns the CLLW ORE ciphertext from the `oc` field of a single sv element +--! supplied as raw jsonb. Inlinable single-statement SQL — the planner folds +--! the body into the calling query. +--! +--! **Missing-`oc` semantics**: returns SQL-level NULL (not a composite with +--! NULL bytes) when `oc` is absent, so btree's NULL handling filters those +--! rows from range queries. +--! +--! @param val jsonb An object carrying an `oc` field +--! @return eql_v3_internal.ore_cllw Composite carrying the CLLW ciphertext, or NULL +--! when the `oc` field is absent. +--! @see eql_v3_internal.has_ore_cllw +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.ore_cllw(val jsonb) + RETURNS eql_v3_internal.ore_cllw + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT CASE WHEN val ->> 'oc' IS NULL THEN NULL + ELSE ROW(decode(val ->> 'oc', 'hex'))::eql_v3_internal.ore_cllw + END +$$; + +COMMENT ON FUNCTION eql_v3_internal.ore_cllw(jsonb) IS + 'eql-inline-critical: raw-jsonb CLLW extractor; must stay inlinable (unpinned search_path)'; + +--! @brief Check if a raw jsonb value contains a CLLW ORE index term +--! @param val jsonb An object that may carry an `oc` field +--! @return boolean True if `oc` field is present and non-null +CREATE FUNCTION eql_v3_internal.has_ore_cllw(val jsonb) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT val ->> 'oc' IS NOT NULL +$$; + +COMMENT ON FUNCTION eql_v3_internal.has_ore_cllw(jsonb) IS + 'eql-inline-critical: raw-jsonb CLLW presence helper; must stay inlinable (unpinned search_path)'; + +--! @brief CLLW per-byte comparison helper +--! @internal +--! +--! Byte-by-byte comparison implementing the CLLW order-revealing protocol. +--! Identify the index of the first differing byte; if `(y_byte + 1) == x_byte` +--! (mod 256) there, then x > y; otherwise x < y. Equal inputs return 0. Inputs +--! MUST be the same length (the caller guarantees this). Stays `LANGUAGE +--! plpgsql` — the per-byte loop can't be a single inlinable SQL expression. +--! +--! @param a bytea First CLLW ciphertext slice +--! @param b bytea Second CLLW ciphertext slice +--! @return integer -1, 0, or 1 +--! @throws Exception if inputs are different lengths +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.compare_ore_cllw_term_bytes(a bytea, b bytea) +RETURNS int + SET search_path = pg_catalog, extensions, public +AS $$ +DECLARE + len_a INT; + len_b INT; + i INT; + first_diff INT := 0; +BEGIN + + len_a := LENGTH(a); + len_b := LENGTH(b); + + IF len_a != len_b THEN + RAISE EXCEPTION 'ore_cllw index terms are not the same length'; + END IF; + + FOR i IN 1..len_a LOOP + IF first_diff = 0 AND get_byte(a, i - 1) != get_byte(b, i - 1) THEN + first_diff := i; + END IF; + END LOOP; + + IF first_diff = 0 THEN + RETURN 0; + END IF; + + IF ((get_byte(b, first_diff - 1) + 1) & 255) = get_byte(a, first_diff - 1) THEN + RETURN 1; + ELSE + RETURN -1; + END IF; +END; +$$ LANGUAGE plpgsql; + +--! @brief Variable-length CLLW ORE term comparison +--! @internal +--! +--! Three-way comparison of two CLLW ORE ciphertext terms of potentially +--! different lengths. Compares the shared prefix via the CLLW per-byte +--! protocol; on equal prefixes, the shorter input sorts first. The leading +--! domain-tag byte makes numeric (`0x00`) sort before string (`0x01`). Stays +--! `LANGUAGE plpgsql` because it dispatches to `compare_ore_cllw_term_bytes`. +--! +--! btree filters NULL composites at the row level, so this should never see a +--! NULL composite under normal operation; the IS-NULL guard returns NULL +--! defensively. A non-NULL composite with NULL `bytes` is a contract violation +--! — the extractor returns SQL NULL (not ROW(NULL)) on missing `oc`, so raise +--! loudly rather than silently misorder. +--! +--! @param a eql_v3_internal.ore_cllw First term +--! @param b eql_v3_internal.ore_cllw Second term +--! @return integer -1, 0, or 1; NULL if either composite is NULL +--! @throws Exception if either composite has a NULL `bytes` field +--! @see eql_v3_internal.compare_ore_cllw_term_bytes +CREATE FUNCTION eql_v3_internal.compare_ore_cllw_term(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) +RETURNS int + SET search_path = pg_catalog, extensions, public +AS $$ +DECLARE + len_a INT; + len_b INT; + common_len INT; + cmp_result INT; +BEGIN + -- The `::text` cast is load-bearing, not a stylistic choice. For the + -- single-field `ore_cllw` composite, `ROW(NULL)::ore_cllw IS NULL` is TRUE + -- but `(ROW(NULL)::ore_cllw)::text IS NULL` is FALSE. Casting to text first + -- means a NULL-component composite falls THROUGH to the RAISE below (the + -- extractor-invariant violation) instead of silently returning NULL and + -- masking it. A plain `a IS NULL` would reintroduce that masking bug. + IF a::text IS NULL OR b::text IS NULL THEN + RETURN NULL; + END IF; + + IF a.bytes IS NULL OR b.bytes IS NULL THEN + RAISE EXCEPTION 'eql_v3_internal.compare_ore_cllw_term: composite has NULL bytes field — extractor invariant violated. Check that the index expression uses eql_v3_internal.ore_cllw(...) and not a hand-crafted ROW(NULL).'; + END IF; + + len_a := LENGTH(a.bytes); + len_b := LENGTH(b.bytes); + + IF len_a = 0 AND len_b = 0 THEN + RETURN 0; + ELSIF len_a = 0 THEN + RETURN -1; + ELSIF len_b = 0 THEN + RETURN 1; + END IF; + + IF len_a < len_b THEN + common_len := len_a; + ELSE + common_len := len_b; + END IF; + + cmp_result := eql_v3_internal.compare_ore_cllw_term_bytes( + SUBSTRING(a.bytes FROM 1 FOR common_len), + SUBSTRING(b.bytes FROM 1 FOR common_len) + ); + + IF cmp_result = -1 THEN + RETURN -1; + ELSIF cmp_result = 1 THEN + RETURN 1; + END IF; + + IF len_a < len_b THEN + RETURN -1; + ELSIF len_a > len_b THEN + RETURN 1; + ELSE + RETURN 0; + END IF; +END; +$$ LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ore_functions.sql +--! @brief Functions for eql_v3.timestamp_ord_ore. + +--! @brief Index extractor for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a 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) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.timestamp_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.timestamp_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.timestamp_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.timestamp_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.timestamp_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.timestamp_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param selector text +--! @return eql_v3.timestamp_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_ord_ore, selector text) +RETURNS eql_v3.timestamp_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param selector integer +--! @return eql_v3.timestamp_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_ord_ore, selector integer) +RETURNS eql_v3.timestamp_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.timestamp_ord_ore +--! @return eql_v3.timestamp_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.timestamp_ord_ore) +RETURNS eql_v3.timestamp_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.timestamp_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.timestamp_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.timestamp_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.timestamp_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.timestamp_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.timestamp_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.timestamp_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.timestamp_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.timestamp_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.timestamp_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b eql_v3.timestamp_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.timestamp_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ope_functions.sql +--! @brief Functions for eql_v3.timestamp_ord_ope. + +--! @brief Index extractor for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a 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 eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.timestamp_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.timestamp_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.timestamp_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.timestamp_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.timestamp_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.timestamp_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.timestamp_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.timestamp_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.timestamp_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.timestamp_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.timestamp_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.timestamp_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.timestamp_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.timestamp_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param selector text +--! @return eql_v3.timestamp_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_ord_ope, selector text) +RETURNS eql_v3.timestamp_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param selector integer +--! @return eql_v3.timestamp_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_ord_ope, selector integer) +RETURNS eql_v3.timestamp_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.timestamp_ord_ope +--! @return eql_v3.timestamp_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.timestamp_ord_ope) +RETURNS eql_v3.timestamp_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.timestamp_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.timestamp_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.timestamp_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.timestamp_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.timestamp_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.timestamp_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.timestamp_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.timestamp_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.timestamp_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.timestamp_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b eql_v3.timestamp_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.timestamp_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_functions.sql +--! @brief Functions for eql_v3.timestamp_ord. + +--! @brief Index extractor for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.timestamp_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_ord, b 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 eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.timestamp_ord) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_ord, b 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 eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.timestamp_ord) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.timestamp_ord, b 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 eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a 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::eql_v3.timestamp_ord) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.timestamp_ord, b 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 eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a 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::eql_v3.timestamp_ord) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.timestamp_ord, b 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 eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a 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::eql_v3.timestamp_ord) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.timestamp_ord, b 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 eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a 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::eql_v3.timestamp_ord) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param selector text +--! @return eql_v3.timestamp_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_ord, selector text) +RETURNS eql_v3.timestamp_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param selector integer +--! @return eql_v3.timestamp_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_ord, selector integer) +RETURNS eql_v3.timestamp_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a jsonb +--! @param selector eql_v3.timestamp_ord +--! @return eql_v3.timestamp_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.timestamp_ord) +RETURNS eql_v3.timestamp_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a jsonb +--! @param selector eql_v3.timestamp_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.timestamp_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.timestamp_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.timestamp_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.timestamp_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.timestamp_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.timestamp_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.timestamp_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.timestamp_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.timestamp_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b eql_v3.timestamp_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.timestamp_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_search_functions.sql +--! @brief Functions for eql_v3.text_search. + +--! @brief Index extractor for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a 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) $$; + +--! @brief Index extractor for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.text_search) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Index extractor for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @return eql_v3_internal.bloom_filter +CREATE FUNCTION eql_v3.match_term(a 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.text_search. +--! @param a eql_v3.text_search +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.text_search, b 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.text_search. +--! @param a eql_v3.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.text_search) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a jsonb +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_search) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.text_search, b 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.text_search. +--! @param a eql_v3.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.text_search) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a jsonb +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_search) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.text_search, b eql_v3.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.text_search. +--! @param a eql_v3.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a 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::eql_v3.text_search) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a jsonb +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_search) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.text_search, b eql_v3.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.text_search. +--! @param a eql_v3.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a 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::eql_v3.text_search) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a jsonb +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_search) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.text_search, b eql_v3.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.text_search. +--! @param a eql_v3.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a 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::eql_v3.text_search) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a jsonb +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_search) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.text_search, b eql_v3.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.text_search. +--! @param a eql_v3.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a 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::eql_v3.text_search) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a jsonb +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_search) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.text_search, b 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.text_search. +--! @param a eql_v3.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(a 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::eql_v3.text_search) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a jsonb +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::eql_v3.text_search) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.text_search, b 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.text_search. +--! @param a eql_v3.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a 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::eql_v3.text_search) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a jsonb +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::eql_v3.text_search) <@ eql_v3.match_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param selector text +--! @return eql_v3.text_search +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_search, selector text) +RETURNS eql_v3.text_search IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param selector integer +--! @return eql_v3.text_search +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_search, selector integer) +RETURNS eql_v3.text_search IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a jsonb +--! @param selector eql_v3.text_search +--! @return eql_v3.text_search +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text_search) +RETURNS eql_v3.text_search IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_search, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_search, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a jsonb +--! @param selector eql_v3.text_search +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text_search) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text_search, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text_search, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text_search, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text_search, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text_search, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text_search, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text_search, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_search, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_search, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_search, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text_search, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b eql_v3.text_search +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_search, b eql_v3.text_search) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_search, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a jsonb +--! @param b eql_v3.text_search +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text_search) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ore_functions.sql +--! @brief Functions for eql_v3.text_ord_ore. + +--! @brief Index extractor for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a 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) $$; + +--! @brief Index extractor for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a 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) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.text_ord_ore, b 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.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.text_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord_ore) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.text_ord_ore, b 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.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.text_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord_ore) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.text_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.text_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.text_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.text_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param selector text +--! @return eql_v3.text_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_ord_ore, selector text) +RETURNS eql_v3.text_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param selector integer +--! @return eql_v3.text_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_ord_ore, selector integer) +RETURNS eql_v3.text_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.text_ord_ore +--! @return eql_v3.text_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text_ord_ore) +RETURNS eql_v3.text_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.text_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b eql_v3.text_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param b eql_v3.text_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ope_functions.sql +--! @brief Functions for eql_v3.text_ord_ope. + +--! @brief Index extractor for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a 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 Index extractor for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a 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 Operator wrapper for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.text_ord_ope, b 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.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.text_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a jsonb +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord_ope) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.text_ord_ope, b 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.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.text_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a jsonb +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord_ope) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.text_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a jsonb +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.text_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.text_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a jsonb +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.text_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.text_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a jsonb +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.text_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.text_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a jsonb +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.text_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a jsonb +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.text_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a jsonb +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.text_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param selector text +--! @return eql_v3.text_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_ord_ope, selector text) +RETURNS eql_v3.text_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param selector integer +--! @return eql_v3.text_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_ord_ope, selector integer) +RETURNS eql_v3.text_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.text_ord_ope +--! @return eql_v3.text_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text_ord_ope) +RETURNS eql_v3.text_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.text_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b eql_v3.text_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a jsonb +--! @param b eql_v3.text_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_functions.sql +--! @brief Functions for eql_v3.text_ord. + +--! @brief Index extractor for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a 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) $$; + +--! @brief Index extractor for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.text_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.text_ord, b 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.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.text_ord) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a jsonb +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.text_ord, b 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.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.text_ord) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a jsonb +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord, b 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.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.text_ord) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a jsonb +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord, b 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.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.text_ord) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a jsonb +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord, b 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.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.text_ord) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a jsonb +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord, b 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.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.text_ord) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a jsonb +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_ord, b eql_v3.text_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a jsonb +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.text_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_ord, b eql_v3.text_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a jsonb +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.text_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param selector text +--! @return eql_v3.text_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_ord, selector text) +RETURNS eql_v3.text_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param selector integer +--! @return eql_v3.text_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_ord, selector integer) +RETURNS eql_v3.text_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a jsonb +--! @param selector eql_v3.text_ord +--! @return eql_v3.text_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text_ord) +RETURNS eql_v3.text_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a jsonb +--! @param selector eql_v3.text_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b eql_v3.text_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_ord, b eql_v3.text_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a jsonb +--! @param b eql_v3.text_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ore_functions.sql +--! @brief Functions for eql_v3.smallint_ord_ore. + +--! @brief Index extractor for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.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.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.smallint_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.smallint_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.smallint_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.smallint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.smallint_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.smallint_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.smallint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.smallint_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.smallint_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.smallint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.smallint_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.smallint_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.smallint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.smallint_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_ord_ore, b eql_v3.smallint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.smallint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_ord_ore, b eql_v3.smallint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.smallint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param selector text +--! @return eql_v3.smallint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_ord_ore, selector text) +RETURNS eql_v3.smallint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param selector integer +--! @return eql_v3.smallint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_ord_ore, selector integer) +RETURNS eql_v3.smallint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.smallint_ord_ore +--! @return eql_v3.smallint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.smallint_ord_ore) +RETURNS eql_v3.smallint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.smallint_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.smallint_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.smallint_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.smallint_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.smallint_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.smallint_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.smallint_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.smallint_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.smallint_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.smallint_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b eql_v3.smallint_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_ord_ore, b eql_v3.smallint_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.smallint_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ope_functions.sql +--! @brief Functions for eql_v3.smallint_ord_ope. + +--! @brief Index extractor for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a 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 eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.smallint_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.smallint_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.smallint_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.smallint_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.smallint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.smallint_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.smallint_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.smallint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.smallint_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.smallint_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.smallint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.smallint_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.smallint_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.smallint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.smallint_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.smallint_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.smallint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.smallint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param selector text +--! @return eql_v3.smallint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_ord_ope, selector text) +RETURNS eql_v3.smallint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param selector integer +--! @return eql_v3.smallint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_ord_ope, selector integer) +RETURNS eql_v3.smallint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.smallint_ord_ope +--! @return eql_v3.smallint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.smallint_ord_ope) +RETURNS eql_v3.smallint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.smallint_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.smallint_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.smallint_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.smallint_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.smallint_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.smallint_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.smallint_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.smallint_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.smallint_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.smallint_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b eql_v3.smallint_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.smallint_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_functions.sql +--! @brief Functions for eql_v3.smallint_ord. + +--! @brief Index extractor for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.smallint_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_ord, b 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.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.smallint_ord) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord. +--! @param a jsonb +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_ord, b 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.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.smallint_ord) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord. +--! @param a jsonb +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.smallint_ord, b 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.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.smallint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.smallint_ord) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord. +--! @param a jsonb +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.smallint_ord, b 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.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.smallint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.smallint_ord) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord. +--! @param a jsonb +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.smallint_ord, b 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.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.smallint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.smallint_ord) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord. +--! @param a jsonb +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.smallint_ord, b 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.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.smallint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.smallint_ord) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord. +--! @param a jsonb +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_ord, b eql_v3.smallint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a jsonb +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.smallint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_ord, b eql_v3.smallint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a jsonb +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.smallint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param selector text +--! @return eql_v3.smallint_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_ord, selector text) +RETURNS eql_v3.smallint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param selector integer +--! @return eql_v3.smallint_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_ord, selector integer) +RETURNS eql_v3.smallint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a jsonb +--! @param selector eql_v3.smallint_ord +--! @return eql_v3.smallint_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.smallint_ord) +RETURNS eql_v3.smallint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a jsonb +--! @param selector eql_v3.smallint_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.smallint_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.smallint_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.smallint_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.smallint_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.smallint_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.smallint_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.smallint_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.smallint_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.smallint_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b eql_v3.smallint_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_ord, b eql_v3.smallint_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a jsonb +--! @param b eql_v3.smallint_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.smallint_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ore_functions.sql +--! @brief Functions for eql_v3.real_ord_ore. + +--! @brief Index extractor for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a 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 eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.real_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a jsonb +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.real_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a jsonb +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.real_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a jsonb +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.real_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a jsonb +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.real_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a jsonb +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.real_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a jsonb +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a jsonb +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.real_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a jsonb +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.real_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param selector text +--! @return eql_v3.real_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_ord_ore, selector text) +RETURNS eql_v3.real_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param selector integer +--! @return eql_v3.real_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_ord_ore, selector integer) +RETURNS eql_v3.real_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.real_ord_ore +--! @return eql_v3.real_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.real_ord_ore) +RETURNS eql_v3.real_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.real_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.real_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.real_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.real_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.real_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.real_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.real_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.real_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.real_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.real_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b eql_v3.real_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a jsonb +--! @param b eql_v3.real_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.real_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ope_functions.sql +--! @brief Functions for eql_v3.real_ord_ope. + +--! @brief Index extractor for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.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.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.real_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a jsonb +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.real_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.real_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a jsonb +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.real_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.real_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a jsonb +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.real_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.real_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a jsonb +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.real_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.real_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a jsonb +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.real_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.real_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a jsonb +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.real_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a jsonb +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.real_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a jsonb +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.real_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param selector text +--! @return eql_v3.real_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_ord_ope, selector text) +RETURNS eql_v3.real_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param selector integer +--! @return eql_v3.real_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_ord_ope, selector integer) +RETURNS eql_v3.real_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.real_ord_ope +--! @return eql_v3.real_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.real_ord_ope) +RETURNS eql_v3.real_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.real_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.real_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.real_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.real_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.real_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.real_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.real_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.real_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.real_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.real_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b eql_v3.real_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a jsonb +--! @param b eql_v3.real_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.real_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_functions.sql +--! @brief Functions for eql_v3.real_ord. + +--! @brief Index extractor for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.real_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.real_ord, b 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.real_ord. +--! @param a eql_v3.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.real_ord) $$; + +--! @brief Operator wrapper for eql_v3.real_ord. +--! @param a jsonb +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.real_ord, b 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.real_ord. +--! @param a eql_v3.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.real_ord) $$; + +--! @brief Operator wrapper for eql_v3.real_ord. +--! @param a jsonb +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.real_ord, b 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.real_ord. +--! @param a eql_v3.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a 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::eql_v3.real_ord) $$; + +--! @brief Operator wrapper for eql_v3.real_ord. +--! @param a jsonb +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.real_ord, b 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.real_ord. +--! @param a eql_v3.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a 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::eql_v3.real_ord) $$; + +--! @brief Operator wrapper for eql_v3.real_ord. +--! @param a jsonb +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.real_ord, b 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.real_ord. +--! @param a eql_v3.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a 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::eql_v3.real_ord) $$; + +--! @brief Operator wrapper for eql_v3.real_ord. +--! @param a jsonb +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.real_ord, b 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.real_ord. +--! @param a eql_v3.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a 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::eql_v3.real_ord) $$; + +--! @brief Operator wrapper for eql_v3.real_ord. +--! @param a jsonb +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_ord, b eql_v3.real_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a jsonb +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.real_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_ord, b eql_v3.real_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a jsonb +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.real_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param selector text +--! @return eql_v3.real_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_ord, selector text) +RETURNS eql_v3.real_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param selector integer +--! @return eql_v3.real_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_ord, selector integer) +RETURNS eql_v3.real_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a jsonb +--! @param selector eql_v3.real_ord +--! @return eql_v3.real_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.real_ord) +RETURNS eql_v3.real_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a jsonb +--! @param selector eql_v3.real_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.real_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.real_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.real_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.real_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.real_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.real_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.real_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.real_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.real_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b eql_v3.real_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_ord, b eql_v3.real_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a jsonb +--! @param b eql_v3.real_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.real_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ore_functions.sql +--! @brief Functions for eql_v3.numeric_ord_ore. + +--! @brief Index extractor for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a 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 eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.numeric_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.numeric_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.numeric_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a 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::eql_v3.numeric_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.numeric_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a 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::eql_v3.numeric_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.numeric_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a 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::eql_v3.numeric_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.numeric_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a 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::eql_v3.numeric_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.numeric_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.numeric_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param selector text +--! @return eql_v3.numeric_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_ord_ore, selector text) +RETURNS eql_v3.numeric_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param selector integer +--! @return eql_v3.numeric_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_ord_ore, selector integer) +RETURNS eql_v3.numeric_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.numeric_ord_ore +--! @return eql_v3.numeric_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.numeric_ord_ore) +RETURNS eql_v3.numeric_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.numeric_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.numeric_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.numeric_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.numeric_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.numeric_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.numeric_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.numeric_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.numeric_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.numeric_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.numeric_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b eql_v3.numeric_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.numeric_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ope_functions.sql +--! @brief Functions for eql_v3.numeric_ord_ope. + +--! @brief Index extractor for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a 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 eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.numeric_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.numeric_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.numeric_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.numeric_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.numeric_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.numeric_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.numeric_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.numeric_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.numeric_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.numeric_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.numeric_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.numeric_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.numeric_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.numeric_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.numeric_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.numeric_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.numeric_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.numeric_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param selector text +--! @return eql_v3.numeric_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_ord_ope, selector text) +RETURNS eql_v3.numeric_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param selector integer +--! @return eql_v3.numeric_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_ord_ope, selector integer) +RETURNS eql_v3.numeric_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.numeric_ord_ope +--! @return eql_v3.numeric_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.numeric_ord_ope) +RETURNS eql_v3.numeric_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.numeric_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.numeric_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.numeric_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.numeric_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.numeric_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.numeric_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.numeric_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.numeric_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.numeric_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.numeric_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b eql_v3.numeric_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.numeric_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_functions.sql +--! @brief Functions for eql_v3.numeric_ord. + +--! @brief Index extractor for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.numeric_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord, b 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.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.numeric_ord) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a jsonb +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord, b 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.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.numeric_ord) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a jsonb +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.numeric_ord, b 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.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a 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::eql_v3.numeric_ord) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a jsonb +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.numeric_ord, b 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.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a 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::eql_v3.numeric_ord) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a jsonb +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.numeric_ord, b 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.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a 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::eql_v3.numeric_ord) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a jsonb +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.numeric_ord, b 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.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a 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::eql_v3.numeric_ord) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a jsonb +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_ord, b eql_v3.numeric_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a jsonb +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.numeric_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_ord, b eql_v3.numeric_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a jsonb +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.numeric_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param selector text +--! @return eql_v3.numeric_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_ord, selector text) +RETURNS eql_v3.numeric_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param selector integer +--! @return eql_v3.numeric_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_ord, selector integer) +RETURNS eql_v3.numeric_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a jsonb +--! @param selector eql_v3.numeric_ord +--! @return eql_v3.numeric_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.numeric_ord) +RETURNS eql_v3.numeric_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a jsonb +--! @param selector eql_v3.numeric_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.numeric_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.numeric_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.numeric_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.numeric_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.numeric_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.numeric_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.numeric_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.numeric_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.numeric_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b eql_v3.numeric_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_ord, b eql_v3.numeric_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a jsonb +--! @param b eql_v3.numeric_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.numeric_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ore_functions.sql +--! @brief Functions for eql_v3.integer_ord_ore. + +--! @brief Index extractor for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a 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 eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.integer_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.integer_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.integer_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.integer_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.integer_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.integer_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.integer_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.integer_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param selector text +--! @return eql_v3.integer_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_ord_ore, selector text) +RETURNS eql_v3.integer_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param selector integer +--! @return eql_v3.integer_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_ord_ore, selector integer) +RETURNS eql_v3.integer_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.integer_ord_ore +--! @return eql_v3.integer_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.integer_ord_ore) +RETURNS eql_v3.integer_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.integer_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.integer_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.integer_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.integer_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.integer_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.integer_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.integer_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.integer_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.integer_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.integer_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b eql_v3.integer_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.integer_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ope_functions.sql +--! @brief Functions for eql_v3.integer_ord_ope. + +--! @brief Index extractor for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a 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 eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.integer_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.integer_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.integer_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.integer_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.integer_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.integer_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.integer_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.integer_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.integer_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.integer_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.integer_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.integer_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.integer_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.integer_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.integer_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.integer_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.integer_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.integer_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.integer_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.integer_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param selector text +--! @return eql_v3.integer_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_ord_ope, selector text) +RETURNS eql_v3.integer_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param selector integer +--! @return eql_v3.integer_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_ord_ope, selector integer) +RETURNS eql_v3.integer_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.integer_ord_ope +--! @return eql_v3.integer_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.integer_ord_ope) +RETURNS eql_v3.integer_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.integer_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.integer_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.integer_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.integer_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.integer_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.integer_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.integer_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.integer_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.integer_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.integer_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b eql_v3.integer_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.integer_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_functions.sql +--! @brief Functions for eql_v3.integer_ord. + +--! @brief Index extractor for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.integer_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.integer_ord, b 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.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.integer_ord) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord. +--! @param a jsonb +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.integer_ord, b 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.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.integer_ord) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord. +--! @param a jsonb +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.integer_ord, b 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.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a 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::eql_v3.integer_ord) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord. +--! @param a jsonb +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.integer_ord, b 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.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a 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::eql_v3.integer_ord) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord. +--! @param a jsonb +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.integer_ord, b 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.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a 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::eql_v3.integer_ord) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord. +--! @param a jsonb +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.integer_ord, b 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.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a 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::eql_v3.integer_ord) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord. +--! @param a jsonb +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_ord, b eql_v3.integer_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a jsonb +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.integer_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_ord, b eql_v3.integer_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a jsonb +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.integer_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param selector text +--! @return eql_v3.integer_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_ord, selector text) +RETURNS eql_v3.integer_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param selector integer +--! @return eql_v3.integer_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_ord, selector integer) +RETURNS eql_v3.integer_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a jsonb +--! @param selector eql_v3.integer_ord +--! @return eql_v3.integer_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.integer_ord) +RETURNS eql_v3.integer_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a jsonb +--! @param selector eql_v3.integer_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.integer_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.integer_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.integer_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.integer_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.integer_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.integer_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.integer_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.integer_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.integer_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b eql_v3.integer_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_ord, b eql_v3.integer_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a jsonb +--! @param b eql_v3.integer_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.integer_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ore_functions.sql +--! @brief Functions for eql_v3.double_ord_ore. + +--! @brief Index extractor for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a 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 eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.double_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a jsonb +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.double_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a jsonb +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.double_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a jsonb +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.double_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a jsonb +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.double_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a jsonb +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.double_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a jsonb +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a jsonb +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.double_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a jsonb +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.double_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param selector text +--! @return eql_v3.double_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_ord_ore, selector text) +RETURNS eql_v3.double_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param selector integer +--! @return eql_v3.double_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_ord_ore, selector integer) +RETURNS eql_v3.double_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.double_ord_ore +--! @return eql_v3.double_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.double_ord_ore) +RETURNS eql_v3.double_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.double_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.double_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.double_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.double_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.double_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.double_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.double_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.double_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.double_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.double_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b eql_v3.double_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a jsonb +--! @param b eql_v3.double_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.double_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ope_functions.sql +--! @brief Functions for eql_v3.double_ord_ope. + +--! @brief Index extractor for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.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.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.double_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.double_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a jsonb +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.double_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.double_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.double_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a jsonb +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.double_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.double_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.double_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a jsonb +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.double_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.double_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.double_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a jsonb +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.double_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.double_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.double_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a jsonb +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.double_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.double_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.double_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a jsonb +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.double_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a jsonb +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.double_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a jsonb +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.double_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param selector text +--! @return eql_v3.double_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_ord_ope, selector text) +RETURNS eql_v3.double_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param selector integer +--! @return eql_v3.double_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_ord_ope, selector integer) +RETURNS eql_v3.double_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.double_ord_ope +--! @return eql_v3.double_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.double_ord_ope) +RETURNS eql_v3.double_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.double_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.double_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.double_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.double_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.double_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.double_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.double_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.double_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.double_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.double_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b eql_v3.double_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a jsonb +--! @param b eql_v3.double_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.double_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_functions.sql +--! @brief Functions for eql_v3.double_ord. + +--! @brief Index extractor for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.double_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.double_ord, b eql_v3.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.double_ord) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a jsonb +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.double_ord, b eql_v3.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.double_ord) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a jsonb +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.double_ord, b eql_v3.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.double_ord) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a jsonb +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.double_ord, b eql_v3.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.double_ord) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a jsonb +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.double_ord, b eql_v3.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.double_ord) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a jsonb +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.double_ord, b eql_v3.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.double_ord) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a jsonb +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_ord, b eql_v3.double_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a jsonb +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.double_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_ord, b eql_v3.double_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a jsonb +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.double_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param selector text +--! @return eql_v3.double_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_ord, selector text) +RETURNS eql_v3.double_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param selector integer +--! @return eql_v3.double_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_ord, selector integer) +RETURNS eql_v3.double_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a jsonb +--! @param selector eql_v3.double_ord +--! @return eql_v3.double_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.double_ord) +RETURNS eql_v3.double_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a jsonb +--! @param selector eql_v3.double_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.double_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.double_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.double_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.double_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.double_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.double_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.double_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.double_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.double_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b eql_v3.double_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_ord, b eql_v3.double_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a jsonb +--! @param b eql_v3.double_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.double_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ore_functions.sql +--! @brief Functions for eql_v3.date_ord_ore. + +--! @brief Index extractor for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a 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 eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.date_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.date_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.date_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.date_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.date_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a 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::eql_v3.date_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.date_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a 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::eql_v3.date_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.date_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a 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::eql_v3.date_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.date_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a 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::eql_v3.date_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.date_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.date_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param selector text +--! @return eql_v3.date_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_ord_ore, selector text) +RETURNS eql_v3.date_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param selector integer +--! @return eql_v3.date_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_ord_ore, selector integer) +RETURNS eql_v3.date_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.date_ord_ore +--! @return eql_v3.date_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.date_ord_ore) +RETURNS eql_v3.date_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.date_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.date_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.date_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.date_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.date_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.date_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.date_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.date_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.date_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.date_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b eql_v3.date_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param b eql_v3.date_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.date_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ope_functions.sql +--! @brief Functions for eql_v3.date_ord_ope. + +--! @brief Index extractor for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a 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 eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.date_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.date_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a jsonb +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.date_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.date_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.date_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a jsonb +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.date_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.date_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.date_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a jsonb +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.date_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.date_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.date_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a jsonb +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.date_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.date_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.date_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a jsonb +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.date_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.date_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.date_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a jsonb +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.date_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a jsonb +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.date_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a jsonb +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.date_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param selector text +--! @return eql_v3.date_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_ord_ope, selector text) +RETURNS eql_v3.date_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param selector integer +--! @return eql_v3.date_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_ord_ope, selector integer) +RETURNS eql_v3.date_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.date_ord_ope +--! @return eql_v3.date_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.date_ord_ope) +RETURNS eql_v3.date_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.date_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.date_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.date_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.date_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.date_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.date_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.date_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.date_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.date_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.date_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b eql_v3.date_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a jsonb +--! @param b eql_v3.date_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.date_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_functions.sql +--! @brief Functions for eql_v3.date_ord. + +--! @brief Index extractor for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.date_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.date_ord, b 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.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.date_ord) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a jsonb +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.date_ord, b 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.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.date_ord) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a jsonb +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.date_ord, b 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.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a 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::eql_v3.date_ord) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a jsonb +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.date_ord, b 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.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a 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::eql_v3.date_ord) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a jsonb +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.date_ord, b 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.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a 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::eql_v3.date_ord) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a jsonb +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.date_ord, b 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.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a 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::eql_v3.date_ord) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a jsonb +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_ord, b eql_v3.date_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a jsonb +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.date_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_ord, b eql_v3.date_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a jsonb +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.date_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param selector text +--! @return eql_v3.date_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_ord, selector text) +RETURNS eql_v3.date_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param selector integer +--! @return eql_v3.date_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_ord, selector integer) +RETURNS eql_v3.date_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a jsonb +--! @param selector eql_v3.date_ord +--! @return eql_v3.date_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.date_ord) +RETURNS eql_v3.date_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a jsonb +--! @param selector eql_v3.date_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.date_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.date_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.date_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.date_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.date_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.date_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.date_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.date_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.date_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b eql_v3.date_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_ord, b eql_v3.date_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a jsonb +--! @param b eql_v3.date_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.date_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/boolean/boolean_types.sql +--! @brief Encrypted-domain types for boolean. + +DO $$ +BEGIN + --! @brief Encrypted domain eql_v3.boolean. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'boolean' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ore_functions.sql +--! @brief Functions for eql_v3.bigint_ord_ore. + +--! @brief Index extractor for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a 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 Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.bigint_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.bigint_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.bigint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.bigint_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.bigint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.bigint_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.bigint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.bigint_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.bigint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.bigint_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param selector text +--! @return eql_v3.bigint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_ord_ore, selector text) +RETURNS eql_v3.bigint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param selector integer +--! @return eql_v3.bigint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_ord_ore, selector integer) +RETURNS eql_v3.bigint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.bigint_ord_ore +--! @return eql_v3.bigint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.bigint_ord_ore) +RETURNS eql_v3.bigint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.bigint_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.bigint_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.bigint_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.bigint_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.bigint_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.bigint_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.bigint_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.bigint_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.bigint_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.bigint_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b eql_v3.bigint_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.bigint_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ope_functions.sql +--! @brief Functions for eql_v3.bigint_ord_ope. + +--! @brief Index extractor for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a 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 eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.bigint_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.bigint_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.bigint_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.bigint_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.bigint_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.bigint_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.bigint_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.bigint_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.bigint_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.bigint_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.bigint_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.bigint_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.bigint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.bigint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param selector text +--! @return eql_v3.bigint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_ord_ope, selector text) +RETURNS eql_v3.bigint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param selector integer +--! @return eql_v3.bigint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_ord_ope, selector integer) +RETURNS eql_v3.bigint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.bigint_ord_ope +--! @return eql_v3.bigint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.bigint_ord_ope) +RETURNS eql_v3.bigint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.bigint_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.bigint_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.bigint_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.bigint_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.bigint_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.bigint_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.bigint_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.bigint_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.bigint_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.bigint_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b eql_v3.bigint_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.bigint_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_functions.sql +--! @brief Functions for eql_v3.bigint_ord. + +--! @brief Index extractor for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.bigint_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_ord, b 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 Operator wrapper for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.bigint_ord) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord. +--! @param a jsonb +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_ord, b 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 Operator wrapper for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.bigint_ord) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord. +--! @param a jsonb +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.bigint_ord, b 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 Operator wrapper for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a 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::eql_v3.bigint_ord) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord. +--! @param a jsonb +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.bigint_ord, b 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 Operator wrapper for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a 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::eql_v3.bigint_ord) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord. +--! @param a jsonb +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.bigint_ord, b 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 Operator wrapper for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a 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::eql_v3.bigint_ord) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord. +--! @param a jsonb +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.bigint_ord, b 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 Operator wrapper for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a 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::eql_v3.bigint_ord) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord. +--! @param a jsonb +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_ord, b eql_v3.bigint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a jsonb +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.bigint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_ord, b eql_v3.bigint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a jsonb +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.bigint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param selector text +--! @return eql_v3.bigint_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_ord, selector text) +RETURNS eql_v3.bigint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param selector integer +--! @return eql_v3.bigint_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_ord, selector integer) +RETURNS eql_v3.bigint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a jsonb +--! @param selector eql_v3.bigint_ord +--! @return eql_v3.bigint_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.bigint_ord) +RETURNS eql_v3.bigint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a jsonb +--! @param selector eql_v3.bigint_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.bigint_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.bigint_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.bigint_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.bigint_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.bigint_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.bigint_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.bigint_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.bigint_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.bigint_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b eql_v3.bigint_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_ord, b eql_v3.bigint_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a jsonb +--! @param b eql_v3.bigint_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.bigint_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @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): +--! - eql_v3.json — storage/root: an EQL envelope object ({i, v, ...}). +--! - eql_v3.jsonb_entry — a single sv element (returned by `->`). +--! - eql_v3.jsonb_query — 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 `oc`). +CREATE FUNCTION eql_v3_internal.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 ? 'oc')) + OR + (jsonb_typeof(val -> 'oc') = 'string' AND NOT (val ? 'hm')) + ), + false + ) +$$; + +--! @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 +--! `oc`). +CREATE FUNCTION eql_v3_internal.is_valid_ste_vec_query_payload(val jsonb) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT 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 ? 'oc')) + OR + (jsonb_typeof(elem -> 'oc') = 'string' AND NOT (elem ? 'hm')) + ) + ), false) + ), + false + ) +$$; + +--! @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 FUNCTION eql_v3_internal.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 eql_v3_internal.is_valid_ste_vec_entry_payload(elem) + ), + false + ) +$$; + +--! @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 `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":[...]}'::eql_v3.json`. +CREATE DOMAIN eql_v3.json AS jsonb + CHECK ( + eql_v3_internal.is_valid_ste_vec_document_payload(VALUE) + ); + +--! @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 `oc` (CLLW ORE, 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.ore_cllw`. Extra fields (`a`, root +--! `i`/`v` merged in by `->`) are allowed. +--! +--! @see src/v3/jsonb/operators.sql +CREATE DOMAIN eql_v3.jsonb_entry AS jsonb + CHECK ( + eql_v3_internal.is_valid_ste_vec_entry_payload(VALUE) + ); + +--! @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 `oc`). 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":"<sel>","hm":"<hm>"}]}'::eql_v3.jsonb_query`. +--! @see eql_v3.to_ste_vec_query +CREATE DOMAIN eql_v3.jsonb_query AS jsonb + CHECK ( + eql_v3_internal.is_valid_ste_vec_query_payload(VALUE) + ); + +--! @brief Convert an eql_v3.json to a jsonb_query needle. +--! +--! Normalises each sv element down to the matching-relevant fields: `s` plus +--! exactly one of `hm` / `oc`. Other fields (`c`, `a`, `i`/`v`, anything else) +--! 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 eql_v3.json Source encrypted payload +--! @return eql_v3.jsonb_query Query-shaped needle, sv elements normalised. +--! @see eql_v3.jsonb_query +CREATE FUNCTION eql_v3.to_ste_vec_query(e eql_v3.json) + RETURNS eql_v3.jsonb_query + 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', + 'oc', elem -> 'oc' + ) + ) + ) + FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem), + '[]'::jsonb + ) + )::eql_v3.jsonb_query +$$; + +CREATE CAST (eql_v3.json AS eql_v3.jsonb_query) + WITH FUNCTION eql_v3.to_ste_vec_query + AS ASSIGNMENT; + +--! @file v3/sem/ore_cllw/operators.sql +--! @brief Comparison operators on the eql_v3_internal.ore_cllw composite type. +--! +--! Each backing function reduces to a single SELECT over +--! eql_v3_internal.compare_ore_cllw_term(a, b) and is inlinable so the planner can fold +--! it through to functional-index matching. The inner comparator is plpgsql +--! (per-byte loop) and is not inlined — fine for index *match*. +--! +--! @note Deliberately no HASHES / MERGES — the CLLW protocol gives ordering, +--! not a hash; there is no merge-joinable opclass on the other side. +--! @see eql_v3_internal.compare_ore_cllw_term + +--! @brief Equality backing function for eql_v3_internal.ore_cllw. +--! @internal +--! +--! @param a eql_v3_internal.ore_cllw Left operand +--! @param b eql_v3_internal.ore_cllw Right operand +--! @return boolean True if the CLLW ORE terms are equal +--! +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.ore_cllw_eq(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_cllw_term(a, b) = 0 +$$; + +--! @brief Not-equal backing function for eql_v3_internal.ore_cllw. +--! @internal +--! +--! @param a eql_v3_internal.ore_cllw Left operand +--! @param b eql_v3_internal.ore_cllw Right operand +--! @return boolean True if the CLLW ORE terms are not equal +--! +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.ore_cllw_neq(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_cllw_term(a, b) <> 0 +$$; + +--! @brief Less-than backing function for eql_v3_internal.ore_cllw. +--! @internal +--! +--! @param a eql_v3_internal.ore_cllw Left operand +--! @param b eql_v3_internal.ore_cllw Right operand +--! @return boolean True if the left operand is less than the right operand +--! +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.ore_cllw_lt(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_cllw_term(a, b) = -1 +$$; + +--! @brief Less-than-or-equal backing function for eql_v3_internal.ore_cllw. +--! @internal +--! +--! @param a eql_v3_internal.ore_cllw Left operand +--! @param b eql_v3_internal.ore_cllw Right operand +--! @return boolean True if the left operand is less than or equal to the right operand +--! +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.ore_cllw_lte(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_cllw_term(a, b) <> 1 +$$; + +--! @brief Greater-than backing function for eql_v3_internal.ore_cllw. +--! @internal +--! +--! @param a eql_v3_internal.ore_cllw Left operand +--! @param b eql_v3_internal.ore_cllw Right operand +--! @return boolean True if the left operand is greater than the right operand +--! +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.ore_cllw_gt(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_cllw_term(a, b) = 1 +$$; + +--! @brief Greater-than-or-equal backing function for eql_v3_internal.ore_cllw. +--! @internal +--! +--! @param a eql_v3_internal.ore_cllw Left operand +--! @param b eql_v3_internal.ore_cllw Right operand +--! @return boolean True if the left operand is greater than or equal to the right operand +--! +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.ore_cllw_gte(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_cllw_term(a, b) <> -1 +$$; + + +CREATE OPERATOR public.= ( + FUNCTION = eql_v3_internal.ore_cllw_eq, + LEFTARG = eql_v3_internal.ore_cllw, + RIGHTARG = eql_v3_internal.ore_cllw, + COMMUTATOR = OPERATOR(public.=), + NEGATOR = OPERATOR(public.<>), + RESTRICT = eqsel, + JOIN = eqjoinsel +); + +CREATE OPERATOR public.<> ( + FUNCTION = eql_v3_internal.ore_cllw_neq, + LEFTARG = eql_v3_internal.ore_cllw, + RIGHTARG = eql_v3_internal.ore_cllw, + COMMUTATOR = OPERATOR(public.<>), + NEGATOR = OPERATOR(public.=), + RESTRICT = neqsel, + JOIN = neqjoinsel +); + +CREATE OPERATOR public.< ( + FUNCTION = eql_v3_internal.ore_cllw_lt, + LEFTARG = eql_v3_internal.ore_cllw, + RIGHTARG = eql_v3_internal.ore_cllw, + COMMUTATOR = OPERATOR(public.>), + NEGATOR = OPERATOR(public.>=), + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel +); + +CREATE OPERATOR public.<= ( + FUNCTION = eql_v3_internal.ore_cllw_lte, + LEFTARG = eql_v3_internal.ore_cllw, + RIGHTARG = eql_v3_internal.ore_cllw, + COMMUTATOR = OPERATOR(public.>=), + NEGATOR = OPERATOR(public.>), + RESTRICT = scalarlesel, + JOIN = scalarlejoinsel +); + +CREATE OPERATOR public.> ( + FUNCTION = eql_v3_internal.ore_cllw_gt, + LEFTARG = eql_v3_internal.ore_cllw, + RIGHTARG = eql_v3_internal.ore_cllw, + COMMUTATOR = OPERATOR(public.<), + NEGATOR = OPERATOR(public.<=), + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel +); + +CREATE OPERATOR public.>= ( + FUNCTION = eql_v3_internal.ore_cllw_gte, + LEFTARG = eql_v3_internal.ore_cllw, + RIGHTARG = eql_v3_internal.ore_cllw, + COMMUTATOR = OPERATOR(public.<=), + NEGATOR = OPERATOR(public.<), + RESTRICT = scalargesel, + JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ore_operators.sql +--! @brief Operators for eql_v3.timestamp_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ope_operators.sql +--! @brief Operators for eql_v3.timestamp_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_operators.sql +--! @brief Operators for eql_v3.timestamp_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_functions.sql +--! @brief Functions for eql_v3.timestamp. + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.timestamp, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a jsonb +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.timestamp, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a jsonb +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.timestamp, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a jsonb +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.timestamp, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a jsonb +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.timestamp, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a jsonb +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.timestamp, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a jsonb +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a jsonb +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a jsonb +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param selector text +--! @return eql_v3.timestamp +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp, selector text) +RETURNS eql_v3.timestamp IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param selector integer +--! @return eql_v3.timestamp +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp, selector integer) +RETURNS eql_v3.timestamp IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a jsonb +--! @param selector eql_v3.timestamp +--! @return eql_v3.timestamp +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.timestamp) +RETURNS eql_v3.timestamp IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a jsonb +--! @param selector eql_v3.timestamp +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.timestamp) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.timestamp, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.timestamp, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.timestamp, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.timestamp, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.timestamp, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.timestamp, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.timestamp, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.timestamp, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b eql_v3.timestamp +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp, b eql_v3.timestamp) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a jsonb +--! @param b eql_v3.timestamp +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.timestamp) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_eq_functions.sql +--! @brief Functions for eql_v3.timestamp_eq. + +--! @brief Index extractor for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.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.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_eq, b 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.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.timestamp_eq) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_eq. +--! @param a jsonb +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.timestamp_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.timestamp_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_eq, b 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.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.timestamp_eq) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_eq. +--! @param a jsonb +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.timestamp_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.timestamp_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a jsonb +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a jsonb +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a jsonb +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a jsonb +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a jsonb +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a jsonb +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param selector text +--! @return eql_v3.timestamp_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_eq, selector text) +RETURNS eql_v3.timestamp_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param selector integer +--! @return eql_v3.timestamp_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_eq, selector integer) +RETURNS eql_v3.timestamp_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a jsonb +--! @param selector eql_v3.timestamp_eq +--! @return eql_v3.timestamp_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.timestamp_eq) +RETURNS eql_v3.timestamp_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a jsonb +--! @param selector eql_v3.timestamp_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.timestamp_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.timestamp_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.timestamp_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.timestamp_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.timestamp_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.timestamp_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.timestamp_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.timestamp_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.timestamp_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b eql_v3.timestamp_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a jsonb +--! @param b eql_v3.timestamp_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.timestamp_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_search_operators.sql +--! @brief Operators for eql_v3.text_search. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text_search, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text_search, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text_search, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text_search, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.text_search, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.text_search, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.text_search, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.text_search, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.text_search, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.text_search, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.text_search, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_search, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_search, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_search, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.text_search, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text_search, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ore_operators.sql +--! @brief Operators for eql_v3.text_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ope_operators.sql +--! @brief Operators for eql_v3.text_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_operators.sql +--! @brief Operators for eql_v3.text_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.text_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.text_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.text_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.text_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.text_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.text_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_functions.sql +--! @brief Functions for eql_v3.text. + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.text, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a jsonb +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.text, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a jsonb +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.text, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a jsonb +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.text, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a jsonb +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.text, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a jsonb +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.text, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a jsonb +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a jsonb +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a jsonb +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param selector text +--! @return eql_v3.text +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text, selector text) +RETURNS eql_v3.text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param selector integer +--! @return eql_v3.text +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text, selector integer) +RETURNS eql_v3.text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a jsonb +--! @param selector eql_v3.text +--! @return eql_v3.text +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text) +RETURNS eql_v3.text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a jsonb +--! @param selector eql_v3.text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b eql_v3.text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text, b eql_v3.text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a jsonb +--! @param b eql_v3.text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_match_functions.sql +--! @brief Functions for eql_v3.text_match. + +--! @brief Index extractor for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @return eql_v3_internal.bloom_filter +CREATE FUNCTION eql_v3.match_term(a 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 eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.text_match, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a jsonb +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.text_match, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a jsonb +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.text_match, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a jsonb +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.text_match, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a jsonb +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.text_match, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a jsonb +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.text_match, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a jsonb +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Operator wrapper for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.text_match, b 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.text_match. +--! @param a eql_v3.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(a 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::eql_v3.text_match) $$; + +--! @brief Operator wrapper for eql_v3.text_match. +--! @param a jsonb +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::eql_v3.text_match) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.text_match, b 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.text_match. +--! @param a eql_v3.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a 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::eql_v3.text_match) $$; + +--! @brief Operator wrapper for eql_v3.text_match. +--! @param a jsonb +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::eql_v3.text_match) <@ eql_v3.match_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param selector text +--! @return eql_v3.text_match +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_match, selector text) +RETURNS eql_v3.text_match IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param selector integer +--! @return eql_v3.text_match +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_match, selector integer) +RETURNS eql_v3.text_match IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a jsonb +--! @param selector eql_v3.text_match +--! @return eql_v3.text_match +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text_match) +RETURNS eql_v3.text_match IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_match, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_match, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a jsonb +--! @param selector eql_v3.text_match +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text_match) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text_match, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text_match, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text_match, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text_match, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text_match, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text_match, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text_match, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_match, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_match, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_match, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text_match, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b eql_v3.text_match +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_match, b eql_v3.text_match) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_match, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a jsonb +--! @param b eql_v3.text_match +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text_match) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_eq_functions.sql +--! @brief Functions for eql_v3.text_eq. + +--! @brief Index extractor for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a 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 eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.text_eq, b 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 Operator wrapper for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.text_eq) $$; + +--! @brief Operator wrapper for eql_v3.text_eq. +--! @param a jsonb +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.text_eq, b 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 Operator wrapper for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.text_eq) $$; + +--! @brief Operator wrapper for eql_v3.text_eq. +--! @param a jsonb +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.text_eq, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a jsonb +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.text_eq, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a jsonb +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.text_eq, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a jsonb +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.text_eq, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a jsonb +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_eq, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a jsonb +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_eq, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a jsonb +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param selector text +--! @return eql_v3.text_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_eq, selector text) +RETURNS eql_v3.text_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param selector integer +--! @return eql_v3.text_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_eq, selector integer) +RETURNS eql_v3.text_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a jsonb +--! @param selector eql_v3.text_eq +--! @return eql_v3.text_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text_eq) +RETURNS eql_v3.text_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a jsonb +--! @param selector eql_v3.text_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b eql_v3.text_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_eq, b eql_v3.text_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a jsonb +--! @param b eql_v3.text_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ore_operators.sql +--! @brief Operators for eql_v3.smallint_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ope_operators.sql +--! @brief Operators for eql_v3.smallint_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_operators.sql +--! @brief Operators for eql_v3.smallint_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_functions.sql +--! @brief Functions for eql_v3.smallint. + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.smallint, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a jsonb +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.smallint, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a jsonb +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.smallint, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a jsonb +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.smallint, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a jsonb +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.smallint, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a jsonb +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.smallint, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a jsonb +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a jsonb +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a jsonb +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param selector text +--! @return eql_v3.smallint +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint, selector text) +RETURNS eql_v3.smallint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param selector integer +--! @return eql_v3.smallint +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint, selector integer) +RETURNS eql_v3.smallint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a jsonb +--! @param selector eql_v3.smallint +--! @return eql_v3.smallint +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.smallint) +RETURNS eql_v3.smallint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a jsonb +--! @param selector eql_v3.smallint +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.smallint) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.smallint, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.smallint, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.smallint, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.smallint, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.smallint, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.smallint, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.smallint, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.smallint, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b eql_v3.smallint +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint, b eql_v3.smallint) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a jsonb +--! @param b eql_v3.smallint +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.smallint) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_eq_functions.sql +--! @brief Functions for eql_v3.smallint_eq. + +--! @brief Index extractor for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a 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 Operator wrapper for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_eq, b 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.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.smallint_eq) $$; + +--! @brief Operator wrapper for eql_v3.smallint_eq. +--! @param a jsonb +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.smallint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.smallint_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_eq, b 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.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.smallint_eq) $$; + +--! @brief Operator wrapper for eql_v3.smallint_eq. +--! @param a jsonb +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.smallint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.smallint_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.smallint_eq, b eql_v3.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a jsonb +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.smallint_eq, b eql_v3.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a jsonb +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.smallint_eq, b eql_v3.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a jsonb +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.smallint_eq, b eql_v3.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a jsonb +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_eq, b eql_v3.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a jsonb +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_eq, b eql_v3.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a jsonb +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param selector text +--! @return eql_v3.smallint_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_eq, selector text) +RETURNS eql_v3.smallint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param selector integer +--! @return eql_v3.smallint_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_eq, selector integer) +RETURNS eql_v3.smallint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a jsonb +--! @param selector eql_v3.smallint_eq +--! @return eql_v3.smallint_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.smallint_eq) +RETURNS eql_v3.smallint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a jsonb +--! @param selector eql_v3.smallint_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.smallint_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.smallint_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.smallint_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.smallint_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.smallint_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.smallint_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.smallint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.smallint_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.smallint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b eql_v3.smallint_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_eq, b eql_v3.smallint_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a jsonb +--! @param b eql_v3.smallint_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.smallint_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ore_operators.sql +--! @brief Operators for eql_v3.real_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ope_operators.sql +--! @brief Operators for eql_v3.real_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_operators.sql +--! @brief Operators for eql_v3.real_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.real_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.real_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.real_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.real_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.real_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.real_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.real_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.real_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.real_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.real_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.real_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.real_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_functions.sql +--! @brief Functions for eql_v3.real. + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.real, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a jsonb +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.real, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a jsonb +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.real, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a jsonb +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.real, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a jsonb +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.real, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a jsonb +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.real, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a jsonb +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a jsonb +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a jsonb +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param selector text +--! @return eql_v3.real +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real, selector text) +RETURNS eql_v3.real IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param selector integer +--! @return eql_v3.real +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real, selector integer) +RETURNS eql_v3.real IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a jsonb +--! @param selector eql_v3.real +--! @return eql_v3.real +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.real) +RETURNS eql_v3.real IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a jsonb +--! @param selector eql_v3.real +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.real) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.real, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.real, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.real, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.real, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.real, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.real, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.real, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.real, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b eql_v3.real +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real, b eql_v3.real) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a jsonb +--! @param b eql_v3.real +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.real) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_eq_functions.sql +--! @brief Functions for eql_v3.real_eq. + +--! @brief Index extractor for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a 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 Operator wrapper for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.real_eq, b 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.real_eq. +--! @param a eql_v3.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.real_eq) $$; + +--! @brief Operator wrapper for eql_v3.real_eq. +--! @param a jsonb +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.real_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.real_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.real_eq, b 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.real_eq. +--! @param a eql_v3.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.real_eq) $$; + +--! @brief Operator wrapper for eql_v3.real_eq. +--! @param a jsonb +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.real_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.real_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.real_eq, b eql_v3.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a jsonb +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.real_eq, b eql_v3.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a jsonb +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.real_eq, b eql_v3.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a jsonb +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.real_eq, b eql_v3.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a jsonb +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_eq, b eql_v3.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a jsonb +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_eq, b eql_v3.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a jsonb +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param selector text +--! @return eql_v3.real_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_eq, selector text) +RETURNS eql_v3.real_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param selector integer +--! @return eql_v3.real_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_eq, selector integer) +RETURNS eql_v3.real_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a jsonb +--! @param selector eql_v3.real_eq +--! @return eql_v3.real_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.real_eq) +RETURNS eql_v3.real_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a jsonb +--! @param selector eql_v3.real_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.real_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.real_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.real_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.real_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.real_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.real_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.real_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.real_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.real_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b eql_v3.real_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_eq, b eql_v3.real_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a jsonb +--! @param b eql_v3.real_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.real_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ore_operators.sql +--! @brief Operators for eql_v3.numeric_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ope_operators.sql +--! @brief Operators for eql_v3.numeric_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_operators.sql +--! @brief Operators for eql_v3.numeric_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_functions.sql +--! @brief Functions for eql_v3.numeric. + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.numeric, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.numeric, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.numeric, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.numeric, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.numeric, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.numeric, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param selector text +--! @return eql_v3.numeric +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric, selector text) +RETURNS eql_v3.numeric IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param selector integer +--! @return eql_v3.numeric +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric, selector integer) +RETURNS eql_v3.numeric IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param selector eql_v3.numeric +--! @return eql_v3.numeric +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.numeric) +RETURNS eql_v3.numeric IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param selector eql_v3.numeric +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.numeric) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.numeric, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.numeric, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.numeric, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.numeric, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.numeric, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.numeric, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.numeric, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.numeric, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b eql_v3.numeric +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric, b eql_v3.numeric) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param b eql_v3.numeric +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.numeric) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_eq_functions.sql +--! @brief Functions for eql_v3.numeric_eq. + +--! @brief Index extractor for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.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.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_eq, b 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.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.numeric_eq) $$; + +--! @brief Operator wrapper for eql_v3.numeric_eq. +--! @param a jsonb +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.numeric_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.numeric_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_eq, b 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.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.numeric_eq) $$; + +--! @brief Operator wrapper for eql_v3.numeric_eq. +--! @param a jsonb +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.numeric_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.numeric_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.numeric_eq, b eql_v3.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a jsonb +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.numeric_eq, b eql_v3.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a jsonb +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.numeric_eq, b eql_v3.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a jsonb +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.numeric_eq, b eql_v3.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a jsonb +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_eq, b eql_v3.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a jsonb +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_eq, b eql_v3.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a jsonb +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param selector text +--! @return eql_v3.numeric_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_eq, selector text) +RETURNS eql_v3.numeric_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param selector integer +--! @return eql_v3.numeric_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_eq, selector integer) +RETURNS eql_v3.numeric_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a jsonb +--! @param selector eql_v3.numeric_eq +--! @return eql_v3.numeric_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.numeric_eq) +RETURNS eql_v3.numeric_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a jsonb +--! @param selector eql_v3.numeric_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.numeric_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.numeric_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.numeric_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.numeric_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.numeric_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.numeric_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.numeric_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.numeric_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.numeric_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b eql_v3.numeric_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_eq, b eql_v3.numeric_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a jsonb +--! @param b eql_v3.numeric_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.numeric_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ore_operators.sql +--! @brief Operators for eql_v3.integer_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ope_operators.sql +--! @brief Operators for eql_v3.integer_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_operators.sql +--! @brief Operators for eql_v3.integer_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.integer_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.integer_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.integer_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.integer_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.integer_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_functions.sql +--! @brief Functions for eql_v3.integer. + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.integer, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a jsonb +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.integer, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a jsonb +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.integer, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a jsonb +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.integer, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a jsonb +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.integer, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a jsonb +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.integer, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a jsonb +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a jsonb +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a jsonb +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param selector text +--! @return eql_v3.integer +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer, selector text) +RETURNS eql_v3.integer IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param selector integer +--! @return eql_v3.integer +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer, selector integer) +RETURNS eql_v3.integer IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a jsonb +--! @param selector eql_v3.integer +--! @return eql_v3.integer +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.integer) +RETURNS eql_v3.integer IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a jsonb +--! @param selector eql_v3.integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.integer, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.integer, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.integer, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.integer, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.integer, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.integer, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.integer, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.integer, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b eql_v3.integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer, b eql_v3.integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a jsonb +--! @param b eql_v3.integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_eq_functions.sql +--! @brief Functions for eql_v3.integer_eq. + +--! @brief Index extractor for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a 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 eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.integer_eq, b 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 eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.integer_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.integer_eq) $$; + +--! @brief Operator wrapper for eql_v3.integer_eq. +--! @param a jsonb +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.integer_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.integer_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.integer_eq, b 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 eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.integer_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.integer_eq) $$; + +--! @brief Operator wrapper for eql_v3.integer_eq. +--! @param a jsonb +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.integer_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.integer_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.integer_eq, b eql_v3.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a jsonb +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.integer_eq, b eql_v3.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a jsonb +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.integer_eq, b eql_v3.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a jsonb +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.integer_eq, b eql_v3.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a jsonb +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_eq, b eql_v3.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a jsonb +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_eq, b eql_v3.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a jsonb +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param selector text +--! @return eql_v3.integer_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_eq, selector text) +RETURNS eql_v3.integer_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param selector integer +--! @return eql_v3.integer_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_eq, selector integer) +RETURNS eql_v3.integer_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a jsonb +--! @param selector eql_v3.integer_eq +--! @return eql_v3.integer_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.integer_eq) +RETURNS eql_v3.integer_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a jsonb +--! @param selector eql_v3.integer_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.integer_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.integer_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.integer_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.integer_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.integer_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.integer_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.integer_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.integer_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.integer_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b eql_v3.integer_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_eq, b eql_v3.integer_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a jsonb +--! @param b eql_v3.integer_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.integer_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ore_operators.sql +--! @brief Operators for eql_v3.double_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ope_operators.sql +--! @brief Operators for eql_v3.double_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_operators.sql +--! @brief Operators for eql_v3.double_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.double_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.double_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.double_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.double_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.double_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.double_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.double_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.double_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.double_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.double_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.double_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.double_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_functions.sql +--! @brief Functions for eql_v3.double. + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.double, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a jsonb +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.double, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a jsonb +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.double, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a jsonb +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.double, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a jsonb +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.double, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a jsonb +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.double, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a jsonb +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a jsonb +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a jsonb +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param selector text +--! @return eql_v3.double +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double, selector text) +RETURNS eql_v3.double IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param selector integer +--! @return eql_v3.double +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double, selector integer) +RETURNS eql_v3.double IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a jsonb +--! @param selector eql_v3.double +--! @return eql_v3.double +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.double) +RETURNS eql_v3.double IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a jsonb +--! @param selector eql_v3.double +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.double) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.double, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.double, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.double, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.double, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.double, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.double, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.double, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.double, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b eql_v3.double +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double, b eql_v3.double) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a jsonb +--! @param b eql_v3.double +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.double) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_eq_functions.sql +--! @brief Functions for eql_v3.double_eq. + +--! @brief Index extractor for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a 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 eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.double_eq, b 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 eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.double_eq) $$; + +--! @brief Operator wrapper for eql_v3.double_eq. +--! @param a jsonb +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.double_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.double_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.double_eq, b 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 eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.double_eq) $$; + +--! @brief Operator wrapper for eql_v3.double_eq. +--! @param a jsonb +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.double_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.double_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.double_eq, b eql_v3.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a jsonb +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.double_eq, b eql_v3.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a jsonb +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.double_eq, b eql_v3.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a jsonb +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.double_eq, b eql_v3.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a jsonb +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_eq, b eql_v3.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a jsonb +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_eq, b eql_v3.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a jsonb +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param selector text +--! @return eql_v3.double_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_eq, selector text) +RETURNS eql_v3.double_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param selector integer +--! @return eql_v3.double_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_eq, selector integer) +RETURNS eql_v3.double_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a jsonb +--! @param selector eql_v3.double_eq +--! @return eql_v3.double_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.double_eq) +RETURNS eql_v3.double_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a jsonb +--! @param selector eql_v3.double_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.double_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.double_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.double_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.double_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.double_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.double_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.double_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.double_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.double_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b eql_v3.double_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_eq, b eql_v3.double_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a jsonb +--! @param b eql_v3.double_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.double_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ore_operators.sql +--! @brief Operators for eql_v3.date_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ope_operators.sql +--! @brief Operators for eql_v3.date_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_operators.sql +--! @brief Operators for eql_v3.date_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.date_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.date_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.date_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.date_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.date_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_functions.sql +--! @brief Functions for eql_v3.date. + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.date, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.date, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.date, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.date, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.date, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.date, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param selector text +--! @return eql_v3.date +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date, selector text) +RETURNS eql_v3.date IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param selector integer +--! @return eql_v3.date +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date, selector integer) +RETURNS eql_v3.date IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param selector eql_v3.date +--! @return eql_v3.date +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.date) +RETURNS eql_v3.date IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param selector eql_v3.date +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.date) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.date, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.date, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.date, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.date, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.date, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.date, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.date, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.date, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b eql_v3.date +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date, b eql_v3.date) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param b eql_v3.date +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.date) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_eq_functions.sql +--! @brief Functions for eql_v3.date_eq. + +--! @brief Index extractor for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a 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 eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.date_eq, b 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.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.date_eq) $$; + +--! @brief Operator wrapper for eql_v3.date_eq. +--! @param a jsonb +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.date_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.date_eq, b 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.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.date_eq) $$; + +--! @brief Operator wrapper for eql_v3.date_eq. +--! @param a jsonb +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.date_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.date_eq, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a jsonb +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.date_eq, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a jsonb +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.date_eq, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a jsonb +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.date_eq, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a jsonb +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_eq, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a jsonb +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_eq, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a jsonb +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param selector text +--! @return eql_v3.date_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_eq, selector text) +RETURNS eql_v3.date_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param selector integer +--! @return eql_v3.date_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_eq, selector integer) +RETURNS eql_v3.date_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a jsonb +--! @param selector eql_v3.date_eq +--! @return eql_v3.date_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.date_eq) +RETURNS eql_v3.date_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a jsonb +--! @param selector eql_v3.date_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.date_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.date_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.date_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.date_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.date_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.date_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.date_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.date_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.date_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b eql_v3.date_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_eq, b eql_v3.date_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a jsonb +--! @param b eql_v3.date_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.date_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/boolean/boolean_functions.sql +--! @brief Functions for eql_v3.boolean. + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.boolean, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a jsonb +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.boolean, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a jsonb +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.boolean, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a jsonb +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.boolean, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a jsonb +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.boolean, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a jsonb +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.boolean, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a jsonb +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.boolean, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a jsonb +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.boolean, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a jsonb +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param selector text +--! @return eql_v3.boolean +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.boolean, selector text) +RETURNS eql_v3.boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param selector integer +--! @return eql_v3.boolean +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.boolean, selector integer) +RETURNS eql_v3.boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a jsonb +--! @param selector eql_v3.boolean +--! @return eql_v3.boolean +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.boolean) +RETURNS eql_v3.boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.boolean, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.boolean, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a jsonb +--! @param selector eql_v3.boolean +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.boolean) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.boolean, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.boolean, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.boolean, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.boolean, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.boolean, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.boolean, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.boolean, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.boolean, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.boolean, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.boolean, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.boolean, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b eql_v3.boolean +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.boolean, b eql_v3.boolean) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.boolean, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a jsonb +--! @param b eql_v3.boolean +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.boolean) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ore_operators.sql +--! @brief Operators for eql_v3.bigint_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ope_operators.sql +--! @brief Operators for eql_v3.bigint_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_operators.sql +--! @brief Operators for eql_v3.bigint_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_functions.sql +--! @brief Functions for eql_v3.bigint. + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.bigint, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a jsonb +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.bigint, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a jsonb +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.bigint, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a jsonb +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.bigint, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a jsonb +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.bigint, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a jsonb +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.bigint, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a jsonb +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a jsonb +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a jsonb +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param selector text +--! @return eql_v3.bigint +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint, selector text) +RETURNS eql_v3.bigint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param selector integer +--! @return eql_v3.bigint +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint, selector integer) +RETURNS eql_v3.bigint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a jsonb +--! @param selector eql_v3.bigint +--! @return eql_v3.bigint +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.bigint) +RETURNS eql_v3.bigint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a jsonb +--! @param selector eql_v3.bigint +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.bigint) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.bigint, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.bigint, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.bigint, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.bigint, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.bigint, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.bigint, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.bigint, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.bigint, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b eql_v3.bigint +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint, b eql_v3.bigint) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a jsonb +--! @param b eql_v3.bigint +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.bigint) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_eq_functions.sql +--! @brief Functions for eql_v3.bigint_eq. + +--! @brief Index extractor for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a 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 eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_eq, b 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 eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.bigint_eq) $$; + +--! @brief Operator wrapper for eql_v3.bigint_eq. +--! @param a jsonb +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.bigint_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_eq, b 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 eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.bigint_eq) $$; + +--! @brief Operator wrapper for eql_v3.bigint_eq. +--! @param a jsonb +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.bigint_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.bigint_eq, b eql_v3.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a jsonb +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.bigint_eq, b eql_v3.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a jsonb +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.bigint_eq, b eql_v3.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a jsonb +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.bigint_eq, b eql_v3.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a jsonb +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_eq, b eql_v3.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a jsonb +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_eq, b eql_v3.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a jsonb +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param selector text +--! @return eql_v3.bigint_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_eq, selector text) +RETURNS eql_v3.bigint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param selector integer +--! @return eql_v3.bigint_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_eq, selector integer) +RETURNS eql_v3.bigint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a jsonb +--! @param selector eql_v3.bigint_eq +--! @return eql_v3.bigint_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.bigint_eq) +RETURNS eql_v3.bigint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a jsonb +--! @param selector eql_v3.bigint_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.bigint_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.bigint_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.bigint_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.bigint_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.bigint_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.bigint_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.bigint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.bigint_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.bigint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b eql_v3.bigint_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_eq, b eql_v3.bigint_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a jsonb +--! @param b eql_v3.bigint_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.bigint_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @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. + +------------------------------------------------------------------------------ +-- Envelope helpers (eql_v3 owns these; jsonb-only) +------------------------------------------------------------------------------ + +--! @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'); +$$; + +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)'; + +--! @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; + +------------------------------------------------------------------------------ +-- Selector extractors +------------------------------------------------------------------------------ + +--! @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; + +--! @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 eql_v3.jsonb_entry +--! @return text The selector value. +CREATE FUNCTION eql_v3.selector(entry eql_v3.jsonb_entry) + RETURNS text + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT entry ->> 's' +$$; + +------------------------------------------------------------------------------ +-- Equality-term extractor (XOR-aware: coalesce(hm, oc)) +------------------------------------------------------------------------------ + +--! @brief XOR-aware equality term extractor for eql_v3.jsonb_entry. +--! +--! Returns the bytea of whichever deterministic term the sv entry carries — +--! `hm` (HMAC-256) or `oc` (CLLW ORE). 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 eql_v3.jsonb_entry +--! @return bytea Decoded `hm` or `oc` bytes (NULL if entry is NULL). +CREATE FUNCTION eql_v3.eq_term(entry eql_v3.jsonb_entry) + RETURNS bytea + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT decode(coalesce(entry ->> 'hm', entry ->> 'oc'), 'hex') +$$; + +------------------------------------------------------------------------------ +-- ORE CLLW per-entry overloads (live here so sem/ore_cllw stays a leaf) +------------------------------------------------------------------------------ + +--! @brief Extract CLLW ORE index term from a ste_vec entry. +--! +--! `oc` is only ever present on an sv element, never at a root encrypted value, +--! so the typed overload accepts eql_v3.jsonb_entry. Returns SQL NULL when +--! `oc` is absent (btree NULL-filters such rows from range queries). +--! +--! @param entry eql_v3.jsonb_entry +--! @return eql_v3_internal.ore_cllw Composite carrying the CLLW ciphertext, or NULL. +--! @see eql_v3.has_ore_cllw +CREATE FUNCTION eql_v3.ore_cllw(entry eql_v3.jsonb_entry) + RETURNS eql_v3_internal.ore_cllw + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT CASE WHEN entry ->> 'oc' IS NULL THEN NULL + ELSE ROW(decode(entry ->> 'oc', 'hex'))::eql_v3_internal.ore_cllw + END +$$; + +--! @brief Check if a ste_vec entry contains a CLLW ORE index term. +--! @param entry eql_v3.jsonb_entry +--! @return boolean True if `oc` is present and non-null. +CREATE FUNCTION eql_v3.has_ore_cllw(entry eql_v3.jsonb_entry) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT entry ->> 'oc' IS NOT NULL +$$; + +------------------------------------------------------------------------------ +-- sv-array helpers +------------------------------------------------------------------------------ + +--! @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; + + SELECT array_agg(elem) + INTO ary + FROM jsonb_array_elements(sv) AS elem; + + RETURN ary; + END; +$$ LANGUAGE plpgsql; + +--! @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; + +------------------------------------------------------------------------------ +-- Deterministic-fields array for GIN containment +------------------------------------------------------------------------------ + +--! @brief Extract deterministic search fields (s, hm, oc, 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', 'oc', 'op') + GROUP BY elem + ); +$$; + +COMMENT ON FUNCTION eql_v3.jsonb_array(jsonb) IS + 'eql-inline-critical: raw-jsonb deterministic-field array helper; must stay inlinable (unpinned search_path)'; + +------------------------------------------------------------------------------ +-- Containment +------------------------------------------------------------------------------ + +--! @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 +--! `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 +AS $$ + SELECT eql_v3.jsonb_array(a) @> eql_v3.jsonb_array(b); +$$; + +COMMENT ON FUNCTION eql_v3.jsonb_contains(jsonb, jsonb) IS + 'eql-inline-critical: raw-jsonb containment helper; must stay inlinable (unpinned search_path)'; + +--! @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 +--! `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 +AS $$ + SELECT eql_v3.jsonb_array(a) <@ eql_v3.jsonb_array(b); +$$; + +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 Check if an sv array contains a specific sv element. +--! +--! Match = selector equal AND eq_term equal (byte-equality over coalesce(hm, +--! oc)). 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 oc 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; and an oc value carries a leading domain-tag byte an hm never +--! has. Unlike v2's explicit `has_hmac(both)`/`has_ore_cllw(both)`/`ELSE false` +--! CASE, this collapse would wrongly match an hm needle against an oc leaf if +--! their hex bytes were ever identical — which the contract prevents. 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; + + 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::eql_v3.jsonb_entry) = eql_v3.eq_term(b::eql_v3.jsonb_entry) + ); + EXIT WHEN result; + END LOOP; + + RETURN result; + END; +$$ LANGUAGE plpgsql; + +--! @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 eql_v3.json Container. +--! @param b 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 eql_v3.json, b 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); + + IF array_length(sv_b, 1) IS NULL THEN + RETURN true; + END IF; + + IF array_length(sv_a, 1) IS NULL THEN + RETURN false; + END IF; + + result := true; + + 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; + + RETURN result; + END; +$$ LANGUAGE plpgsql; + +------------------------------------------------------------------------------ +-- Path queries (text selector only) +------------------------------------------------------------------------------ + +--! @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 +--! eql_v3.json document, because the root document domain requires an `sv` +--! array and single leaves belong to eql_v3.jsonb_entry. +--! +--! @param val jsonb encrypted EQL payload with `sv`. +--! @param selector text Selector hash (`s` value). +--! @return SETOF 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 eql_v3.jsonb_entry + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT (eql_v3.meta_data(val) || elem)::eql_v3.jsonb_entry + FROM jsonb_array_elements(val -> 'sv') elem + WHERE elem ->> 's' = selector +$$; + +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)'; + +--! @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 + ); +$$; + +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)'; + +--! @brief Get the first sv element matching `selector`, or NULL. +--! @param val jsonb encrypted EQL payload. +--! @param selector text Selector hash to match. +--! @return eql_v3.jsonb_entry First matching element or NULL. +CREATE FUNCTION eql_v3.jsonb_path_query_first(val jsonb, selector text) + RETURNS eql_v3.jsonb_entry + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT (eql_v3.meta_data(val) || elem)::eql_v3.jsonb_entry + FROM jsonb_array_elements(val -> 'sv') elem + WHERE elem ->> 's' = selector + LIMIT 1 +$$; + +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)'; + +------------------------------------------------------------------------------ +-- Array functions +------------------------------------------------------------------------------ + +--! @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; + + RAISE 'cannot get array length of a non-array'; + END; +$$ 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 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 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; + + meta := eql_v3.meta_data(val); + sv := eql_v3.ste_vec(val); + + FOR idx IN 1..array_length(sv, 1) LOOP + item = sv[idx]; + RETURN NEXT (meta || item)::eql_v3.jsonb_entry; + END LOOP; + + RETURN; + END; +$$ LANGUAGE plpgsql; + +--! @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; + + sv := eql_v3.ste_vec(val); + + FOR idx IN 1..array_length(sv, 1) LOOP + RETURN NEXT eql_v3.ciphertext(sv[idx]); + END LOOP; + + RETURN; + END; +$$ LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE +-- Source is src/v3/version.template + +DROP FUNCTION IF EXISTS eql_v3.version(); + +--! @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-alpha.2 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. + +--! @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 +--! -- Check installed EQL version +--! SELECT eql_v3.version(); +--! -- Returns: '3.0.0' +CREATE FUNCTION eql_v3.version() + RETURNS text + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT '3.0.0-alpha.2'; +$$ 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-alpha.2'; + +--! @file encrypted_domain/timestamp/timestamp_ord_ore_aggregates.sql +--! @brief Aggregates for eql_v3.timestamp_ord_ore. + +--! @brief State function for min on eql_v3.timestamp_ord_ore. +--! @param state eql_v3.timestamp_ord_ore +--! @param value eql_v3.timestamp_ord_ore +--! @return eql_v3.timestamp_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.timestamp_ord_ore, value eql_v3.timestamp_ord_ore) +RETURNS 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; +$$; + +--! @brief min aggregate for eql_v3.timestamp_ord_ore. +--! @param input eql_v3.timestamp_ord_ore +--! @return eql_v3.timestamp_ord_ore +CREATE AGGREGATE eql_v3.min(eql_v3.timestamp_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.timestamp_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.timestamp_ord_ore. +--! @param state eql_v3.timestamp_ord_ore +--! @param value eql_v3.timestamp_ord_ore +--! @return eql_v3.timestamp_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.timestamp_ord_ore, value eql_v3.timestamp_ord_ore) +RETURNS 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; +$$; + +--! @brief max aggregate for eql_v3.timestamp_ord_ore. +--! @param input eql_v3.timestamp_ord_ore +--! @return eql_v3.timestamp_ord_ore +CREATE AGGREGATE eql_v3.max(eql_v3.timestamp_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.timestamp_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ope_aggregates.sql +--! @brief Aggregates for eql_v3.timestamp_ord_ope. + +--! @brief State function for min on eql_v3.timestamp_ord_ope. +--! @param state eql_v3.timestamp_ord_ope +--! @param value eql_v3.timestamp_ord_ope +--! @return eql_v3.timestamp_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.timestamp_ord_ope, value eql_v3.timestamp_ord_ope) +RETURNS 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; +$$; + +--! @brief min aggregate for eql_v3.timestamp_ord_ope. +--! @param input eql_v3.timestamp_ord_ope +--! @return eql_v3.timestamp_ord_ope +CREATE AGGREGATE eql_v3.min(eql_v3.timestamp_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.timestamp_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.timestamp_ord_ope. +--! @param state eql_v3.timestamp_ord_ope +--! @param value eql_v3.timestamp_ord_ope +--! @return eql_v3.timestamp_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.timestamp_ord_ope, value eql_v3.timestamp_ord_ope) +RETURNS 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; +$$; + +--! @brief max aggregate for eql_v3.timestamp_ord_ope. +--! @param input eql_v3.timestamp_ord_ope +--! @return eql_v3.timestamp_ord_ope +CREATE AGGREGATE eql_v3.max(eql_v3.timestamp_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.timestamp_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_aggregates.sql +--! @brief Aggregates for eql_v3.timestamp_ord. + +--! @brief State function for min on eql_v3.timestamp_ord. +--! @param state eql_v3.timestamp_ord +--! @param value eql_v3.timestamp_ord +--! @return eql_v3.timestamp_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.timestamp_ord, value eql_v3.timestamp_ord) +RETURNS eql_v3.timestamp_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 eql_v3.timestamp_ord. +--! @param input eql_v3.timestamp_ord +--! @return eql_v3.timestamp_ord +CREATE AGGREGATE eql_v3.min(eql_v3.timestamp_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.timestamp_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.timestamp_ord. +--! @param state eql_v3.timestamp_ord +--! @param value eql_v3.timestamp_ord +--! @return eql_v3.timestamp_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.timestamp_ord, value eql_v3.timestamp_ord) +RETURNS eql_v3.timestamp_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 eql_v3.timestamp_ord. +--! @param input eql_v3.timestamp_ord +--! @return eql_v3.timestamp_ord +CREATE AGGREGATE eql_v3.max(eql_v3.timestamp_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.timestamp_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_operators.sql +--! @brief Operators for eql_v3.timestamp. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.timestamp, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.timestamp, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.timestamp, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.timestamp, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.timestamp, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.timestamp, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.timestamp, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.timestamp, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.timestamp, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.timestamp, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.timestamp, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.timestamp, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_eq_operators.sql +--! @brief Operators for eql_v3.timestamp_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_search_aggregates.sql +--! @brief Aggregates for eql_v3.text_search. + +--! @brief State function for min on eql_v3.text_search. +--! @param state eql_v3.text_search +--! @param value eql_v3.text_search +--! @return eql_v3.text_search +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.text_search, value eql_v3.text_search) +RETURNS 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 min aggregate for eql_v3.text_search. +--! @param input eql_v3.text_search +--! @return eql_v3.text_search +CREATE AGGREGATE eql_v3.min(eql_v3.text_search) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.text_search, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.text_search. +--! @param state eql_v3.text_search +--! @param value eql_v3.text_search +--! @return eql_v3.text_search +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.text_search, value eql_v3.text_search) +RETURNS 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 max aggregate for eql_v3.text_search. +--! @param input eql_v3.text_search +--! @return eql_v3.text_search +CREATE AGGREGATE eql_v3.max(eql_v3.text_search) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.text_search, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ore_aggregates.sql +--! @brief Aggregates for eql_v3.text_ord_ore. + +--! @brief State function for min on eql_v3.text_ord_ore. +--! @param state eql_v3.text_ord_ore +--! @param value eql_v3.text_ord_ore +--! @return eql_v3.text_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.text_ord_ore, value eql_v3.text_ord_ore) +RETURNS 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 eql_v3.text_ord_ore. +--! @param input eql_v3.text_ord_ore +--! @return eql_v3.text_ord_ore +CREATE AGGREGATE eql_v3.min(eql_v3.text_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.text_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.text_ord_ore. +--! @param state eql_v3.text_ord_ore +--! @param value eql_v3.text_ord_ore +--! @return eql_v3.text_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.text_ord_ore, value eql_v3.text_ord_ore) +RETURNS 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 eql_v3.text_ord_ore. +--! @param input eql_v3.text_ord_ore +--! @return eql_v3.text_ord_ore +CREATE AGGREGATE eql_v3.max(eql_v3.text_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.text_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ope_aggregates.sql +--! @brief Aggregates for eql_v3.text_ord_ope. + +--! @brief State function for min on eql_v3.text_ord_ope. +--! @param state eql_v3.text_ord_ope +--! @param value eql_v3.text_ord_ope +--! @return eql_v3.text_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.text_ord_ope, value eql_v3.text_ord_ope) +RETURNS eql_v3.text_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 eql_v3.text_ord_ope. +--! @param input eql_v3.text_ord_ope +--! @return eql_v3.text_ord_ope +CREATE AGGREGATE eql_v3.min(eql_v3.text_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.text_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.text_ord_ope. +--! @param state eql_v3.text_ord_ope +--! @param value eql_v3.text_ord_ope +--! @return eql_v3.text_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.text_ord_ope, value eql_v3.text_ord_ope) +RETURNS eql_v3.text_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 eql_v3.text_ord_ope. +--! @param input eql_v3.text_ord_ope +--! @return eql_v3.text_ord_ope +CREATE AGGREGATE eql_v3.max(eql_v3.text_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.text_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_aggregates.sql +--! @brief Aggregates for eql_v3.text_ord. + +--! @brief State function for min on eql_v3.text_ord. +--! @param state eql_v3.text_ord +--! @param value eql_v3.text_ord +--! @return eql_v3.text_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.text_ord, value eql_v3.text_ord) +RETURNS 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 eql_v3.text_ord. +--! @param input eql_v3.text_ord +--! @return eql_v3.text_ord +CREATE AGGREGATE eql_v3.min(eql_v3.text_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.text_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.text_ord. +--! @param state eql_v3.text_ord +--! @param value eql_v3.text_ord +--! @return eql_v3.text_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.text_ord, value eql_v3.text_ord) +RETURNS 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 eql_v3.text_ord. +--! @param input eql_v3.text_ord +--! @return eql_v3.text_ord +CREATE AGGREGATE eql_v3.max(eql_v3.text_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.text_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_operators.sql +--! @brief Operators for eql_v3.text. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.text, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.text, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.text, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.text, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.text, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.text, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.text, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.text, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.text, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.text, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.text, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.text, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.text, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.text, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.text, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.text, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_match_operators.sql +--! @brief Operators for eql_v3.text_match. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.text_match, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.text_match, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.text_match, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.text_match, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.text_match, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.text_match, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.text_match, RIGHTARG = jsonb, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_match, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.text_match, RIGHTARG = jsonb, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_match, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text_match, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text_match, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text_match, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text_match, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.text_match, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.text_match, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.text_match, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.text_match, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.text_match, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.text_match, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.text_match, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_match, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_match, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_match, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.text_match, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text_match, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_match +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_eq_operators.sql +--! @brief Operators for eql_v3.text_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.text_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ore_aggregates.sql +--! @brief Aggregates for eql_v3.smallint_ord_ore. + +--! @brief State function for min on eql_v3.smallint_ord_ore. +--! @param state eql_v3.smallint_ord_ore +--! @param value eql_v3.smallint_ord_ore +--! @return eql_v3.smallint_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.smallint_ord_ore, value eql_v3.smallint_ord_ore) +RETURNS 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 eql_v3.smallint_ord_ore. +--! @param input eql_v3.smallint_ord_ore +--! @return eql_v3.smallint_ord_ore +CREATE AGGREGATE eql_v3.min(eql_v3.smallint_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.smallint_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.smallint_ord_ore. +--! @param state eql_v3.smallint_ord_ore +--! @param value eql_v3.smallint_ord_ore +--! @return eql_v3.smallint_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.smallint_ord_ore, value eql_v3.smallint_ord_ore) +RETURNS 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 eql_v3.smallint_ord_ore. +--! @param input eql_v3.smallint_ord_ore +--! @return eql_v3.smallint_ord_ore +CREATE AGGREGATE eql_v3.max(eql_v3.smallint_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = 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 eql_v3.smallint_ord_ope. + +--! @brief State function for min on eql_v3.smallint_ord_ope. +--! @param state eql_v3.smallint_ord_ope +--! @param value eql_v3.smallint_ord_ope +--! @return eql_v3.smallint_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.smallint_ord_ope, value eql_v3.smallint_ord_ope) +RETURNS 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 min aggregate for eql_v3.smallint_ord_ope. +--! @param input eql_v3.smallint_ord_ope +--! @return eql_v3.smallint_ord_ope +CREATE AGGREGATE eql_v3.min(eql_v3.smallint_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.smallint_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.smallint_ord_ope. +--! @param state eql_v3.smallint_ord_ope +--! @param value eql_v3.smallint_ord_ope +--! @return eql_v3.smallint_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.smallint_ord_ope, value eql_v3.smallint_ord_ope) +RETURNS 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 max aggregate for eql_v3.smallint_ord_ope. +--! @param input eql_v3.smallint_ord_ope +--! @return eql_v3.smallint_ord_ope +CREATE AGGREGATE eql_v3.max(eql_v3.smallint_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.smallint_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_aggregates.sql +--! @brief Aggregates for eql_v3.smallint_ord. + +--! @brief State function for min on eql_v3.smallint_ord. +--! @param state eql_v3.smallint_ord +--! @param value eql_v3.smallint_ord +--! @return eql_v3.smallint_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.smallint_ord, value eql_v3.smallint_ord) +RETURNS 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 min aggregate for eql_v3.smallint_ord. +--! @param input eql_v3.smallint_ord +--! @return eql_v3.smallint_ord +CREATE AGGREGATE eql_v3.min(eql_v3.smallint_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.smallint_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.smallint_ord. +--! @param state eql_v3.smallint_ord +--! @param value eql_v3.smallint_ord +--! @return eql_v3.smallint_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.smallint_ord, value eql_v3.smallint_ord) +RETURNS 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 max aggregate for eql_v3.smallint_ord. +--! @param input eql_v3.smallint_ord +--! @return eql_v3.smallint_ord +CREATE AGGREGATE eql_v3.max(eql_v3.smallint_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.smallint_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_operators.sql +--! @brief Operators for eql_v3.smallint. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.smallint, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.smallint, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.smallint, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.smallint, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.smallint, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.smallint, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.smallint, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.smallint, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.smallint, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.smallint, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.smallint, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.smallint, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_eq_operators.sql +--! @brief Operators for eql_v3.smallint_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ore_aggregates.sql +--! @brief Aggregates for eql_v3.real_ord_ore. + +--! @brief State function for min on eql_v3.real_ord_ore. +--! @param state eql_v3.real_ord_ore +--! @param value eql_v3.real_ord_ore +--! @return eql_v3.real_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.real_ord_ore, value eql_v3.real_ord_ore) +RETURNS 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 min aggregate for eql_v3.real_ord_ore. +--! @param input eql_v3.real_ord_ore +--! @return eql_v3.real_ord_ore +CREATE AGGREGATE eql_v3.min(eql_v3.real_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.real_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.real_ord_ore. +--! @param state eql_v3.real_ord_ore +--! @param value eql_v3.real_ord_ore +--! @return eql_v3.real_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.real_ord_ore, value eql_v3.real_ord_ore) +RETURNS 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 max aggregate for eql_v3.real_ord_ore. +--! @param input eql_v3.real_ord_ore +--! @return eql_v3.real_ord_ore +CREATE AGGREGATE eql_v3.max(eql_v3.real_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.real_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ope_aggregates.sql +--! @brief Aggregates for eql_v3.real_ord_ope. + +--! @brief State function for min on eql_v3.real_ord_ope. +--! @param state eql_v3.real_ord_ope +--! @param value eql_v3.real_ord_ope +--! @return eql_v3.real_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.real_ord_ope, value eql_v3.real_ord_ope) +RETURNS 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 min aggregate for eql_v3.real_ord_ope. +--! @param input eql_v3.real_ord_ope +--! @return eql_v3.real_ord_ope +CREATE AGGREGATE eql_v3.min(eql_v3.real_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.real_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.real_ord_ope. +--! @param state eql_v3.real_ord_ope +--! @param value eql_v3.real_ord_ope +--! @return eql_v3.real_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.real_ord_ope, value eql_v3.real_ord_ope) +RETURNS 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 max aggregate for eql_v3.real_ord_ope. +--! @param input eql_v3.real_ord_ope +--! @return eql_v3.real_ord_ope +CREATE AGGREGATE eql_v3.max(eql_v3.real_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.real_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_aggregates.sql +--! @brief Aggregates for eql_v3.real_ord. + +--! @brief State function for min on eql_v3.real_ord. +--! @param state eql_v3.real_ord +--! @param value eql_v3.real_ord +--! @return eql_v3.real_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.real_ord, value eql_v3.real_ord) +RETURNS 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 min aggregate for eql_v3.real_ord. +--! @param input eql_v3.real_ord +--! @return eql_v3.real_ord +CREATE AGGREGATE eql_v3.min(eql_v3.real_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.real_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.real_ord. +--! @param state eql_v3.real_ord +--! @param value eql_v3.real_ord +--! @return eql_v3.real_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.real_ord, value eql_v3.real_ord) +RETURNS 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 max aggregate for eql_v3.real_ord. +--! @param input eql_v3.real_ord +--! @return eql_v3.real_ord +CREATE AGGREGATE eql_v3.max(eql_v3.real_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.real_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_operators.sql +--! @brief Operators for eql_v3.real. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.real, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.real, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.real, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.real, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.real, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.real, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.real, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.real, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.real, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.real, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.real, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.real, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.real, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.real, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.real, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.real, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.real, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.real, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.real, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.real, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.real, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.real +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_eq_operators.sql +--! @brief Operators for eql_v3.real_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.real_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.real_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.real_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.real_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.real_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.real_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.real_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.real_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.real_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.real_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.real_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.real_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ore_aggregates.sql +--! @brief Aggregates for eql_v3.numeric_ord_ore. + +--! @brief State function for min on eql_v3.numeric_ord_ore. +--! @param state eql_v3.numeric_ord_ore +--! @param value eql_v3.numeric_ord_ore +--! @return eql_v3.numeric_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.numeric_ord_ore, value eql_v3.numeric_ord_ore) +RETURNS 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 eql_v3.numeric_ord_ore. +--! @param input eql_v3.numeric_ord_ore +--! @return eql_v3.numeric_ord_ore +CREATE AGGREGATE eql_v3.min(eql_v3.numeric_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.numeric_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.numeric_ord_ore. +--! @param state eql_v3.numeric_ord_ore +--! @param value eql_v3.numeric_ord_ore +--! @return eql_v3.numeric_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.numeric_ord_ore, value eql_v3.numeric_ord_ore) +RETURNS 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 eql_v3.numeric_ord_ore. +--! @param input eql_v3.numeric_ord_ore +--! @return eql_v3.numeric_ord_ore +CREATE AGGREGATE eql_v3.max(eql_v3.numeric_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = 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 eql_v3.numeric_ord_ope. + +--! @brief State function for min on eql_v3.numeric_ord_ope. +--! @param state eql_v3.numeric_ord_ope +--! @param value eql_v3.numeric_ord_ope +--! @return eql_v3.numeric_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.numeric_ord_ope, value eql_v3.numeric_ord_ope) +RETURNS 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 eql_v3.numeric_ord_ope. +--! @param input eql_v3.numeric_ord_ope +--! @return eql_v3.numeric_ord_ope +CREATE AGGREGATE eql_v3.min(eql_v3.numeric_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.numeric_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.numeric_ord_ope. +--! @param state eql_v3.numeric_ord_ope +--! @param value eql_v3.numeric_ord_ope +--! @return eql_v3.numeric_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.numeric_ord_ope, value eql_v3.numeric_ord_ope) +RETURNS 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 eql_v3.numeric_ord_ope. +--! @param input eql_v3.numeric_ord_ope +--! @return eql_v3.numeric_ord_ope +CREATE AGGREGATE eql_v3.max(eql_v3.numeric_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.numeric_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_aggregates.sql +--! @brief Aggregates for eql_v3.numeric_ord. + +--! @brief State function for min on eql_v3.numeric_ord. +--! @param state eql_v3.numeric_ord +--! @param value eql_v3.numeric_ord +--! @return eql_v3.numeric_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.numeric_ord, value eql_v3.numeric_ord) +RETURNS 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 min aggregate for eql_v3.numeric_ord. +--! @param input eql_v3.numeric_ord +--! @return eql_v3.numeric_ord +CREATE AGGREGATE eql_v3.min(eql_v3.numeric_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.numeric_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.numeric_ord. +--! @param state eql_v3.numeric_ord +--! @param value eql_v3.numeric_ord +--! @return eql_v3.numeric_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.numeric_ord, value eql_v3.numeric_ord) +RETURNS 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 max aggregate for eql_v3.numeric_ord. +--! @param input eql_v3.numeric_ord +--! @return eql_v3.numeric_ord +CREATE AGGREGATE eql_v3.max(eql_v3.numeric_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.numeric_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_operators.sql +--! @brief Operators for eql_v3.numeric. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.numeric, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.numeric, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.numeric, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.numeric, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.numeric, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.numeric, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.numeric, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_eq_operators.sql +--! @brief Operators for eql_v3.numeric_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ore_aggregates.sql +--! @brief Aggregates for eql_v3.integer_ord_ore. + +--! @brief State function for min on eql_v3.integer_ord_ore. +--! @param state eql_v3.integer_ord_ore +--! @param value eql_v3.integer_ord_ore +--! @return eql_v3.integer_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.integer_ord_ore, value eql_v3.integer_ord_ore) +RETURNS 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 min aggregate for eql_v3.integer_ord_ore. +--! @param input eql_v3.integer_ord_ore +--! @return eql_v3.integer_ord_ore +CREATE AGGREGATE eql_v3.min(eql_v3.integer_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.integer_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.integer_ord_ore. +--! @param state eql_v3.integer_ord_ore +--! @param value eql_v3.integer_ord_ore +--! @return eql_v3.integer_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.integer_ord_ore, value eql_v3.integer_ord_ore) +RETURNS 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 max aggregate for eql_v3.integer_ord_ore. +--! @param input eql_v3.integer_ord_ore +--! @return eql_v3.integer_ord_ore +CREATE AGGREGATE eql_v3.max(eql_v3.integer_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.integer_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ope_aggregates.sql +--! @brief Aggregates for eql_v3.integer_ord_ope. + +--! @brief State function for min on eql_v3.integer_ord_ope. +--! @param state eql_v3.integer_ord_ope +--! @param value eql_v3.integer_ord_ope +--! @return eql_v3.integer_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.integer_ord_ope, value eql_v3.integer_ord_ope) +RETURNS 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 min aggregate for eql_v3.integer_ord_ope. +--! @param input eql_v3.integer_ord_ope +--! @return eql_v3.integer_ord_ope +CREATE AGGREGATE eql_v3.min(eql_v3.integer_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.integer_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.integer_ord_ope. +--! @param state eql_v3.integer_ord_ope +--! @param value eql_v3.integer_ord_ope +--! @return eql_v3.integer_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.integer_ord_ope, value eql_v3.integer_ord_ope) +RETURNS 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 max aggregate for eql_v3.integer_ord_ope. +--! @param input eql_v3.integer_ord_ope +--! @return eql_v3.integer_ord_ope +CREATE AGGREGATE eql_v3.max(eql_v3.integer_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.integer_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_aggregates.sql +--! @brief Aggregates for eql_v3.integer_ord. + +--! @brief State function for min on eql_v3.integer_ord. +--! @param state eql_v3.integer_ord +--! @param value eql_v3.integer_ord +--! @return eql_v3.integer_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.integer_ord, value eql_v3.integer_ord) +RETURNS 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 min aggregate for eql_v3.integer_ord. +--! @param input eql_v3.integer_ord +--! @return eql_v3.integer_ord +CREATE AGGREGATE eql_v3.min(eql_v3.integer_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.integer_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.integer_ord. +--! @param state eql_v3.integer_ord +--! @param value eql_v3.integer_ord +--! @return eql_v3.integer_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.integer_ord, value eql_v3.integer_ord) +RETURNS 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 max aggregate for eql_v3.integer_ord. +--! @param input eql_v3.integer_ord +--! @return eql_v3.integer_ord +CREATE AGGREGATE eql_v3.max(eql_v3.integer_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.integer_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_operators.sql +--! @brief Operators for eql_v3.integer. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.integer, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.integer, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.integer, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.integer, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.integer, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.integer, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.integer, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.integer, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.integer, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.integer, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.integer, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.integer, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_eq_operators.sql +--! @brief Operators for eql_v3.integer_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.integer_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.integer_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.integer_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.integer_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.integer_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ore_aggregates.sql +--! @brief Aggregates for eql_v3.double_ord_ore. + +--! @brief State function for min on eql_v3.double_ord_ore. +--! @param state eql_v3.double_ord_ore +--! @param value eql_v3.double_ord_ore +--! @return eql_v3.double_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.double_ord_ore, value eql_v3.double_ord_ore) +RETURNS 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; +$$; + +--! @brief min aggregate for eql_v3.double_ord_ore. +--! @param input eql_v3.double_ord_ore +--! @return eql_v3.double_ord_ore +CREATE AGGREGATE eql_v3.min(eql_v3.double_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.double_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.double_ord_ore. +--! @param state eql_v3.double_ord_ore +--! @param value eql_v3.double_ord_ore +--! @return eql_v3.double_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.double_ord_ore, value eql_v3.double_ord_ore) +RETURNS 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; +$$; + +--! @brief max aggregate for eql_v3.double_ord_ore. +--! @param input eql_v3.double_ord_ore +--! @return eql_v3.double_ord_ore +CREATE AGGREGATE eql_v3.max(eql_v3.double_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.double_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ope_aggregates.sql +--! @brief Aggregates for eql_v3.double_ord_ope. + +--! @brief State function for min on eql_v3.double_ord_ope. +--! @param state eql_v3.double_ord_ope +--! @param value eql_v3.double_ord_ope +--! @return eql_v3.double_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.double_ord_ope, value eql_v3.double_ord_ope) +RETURNS eql_v3.double_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 eql_v3.double_ord_ope. +--! @param input eql_v3.double_ord_ope +--! @return eql_v3.double_ord_ope +CREATE AGGREGATE eql_v3.min(eql_v3.double_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.double_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.double_ord_ope. +--! @param state eql_v3.double_ord_ope +--! @param value eql_v3.double_ord_ope +--! @return eql_v3.double_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.double_ord_ope, value eql_v3.double_ord_ope) +RETURNS eql_v3.double_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 eql_v3.double_ord_ope. +--! @param input eql_v3.double_ord_ope +--! @return eql_v3.double_ord_ope +CREATE AGGREGATE eql_v3.max(eql_v3.double_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.double_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_aggregates.sql +--! @brief Aggregates for eql_v3.double_ord. + +--! @brief State function for min on eql_v3.double_ord. +--! @param state eql_v3.double_ord +--! @param value eql_v3.double_ord +--! @return eql_v3.double_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.double_ord, value eql_v3.double_ord) +RETURNS 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 min aggregate for eql_v3.double_ord. +--! @param input eql_v3.double_ord +--! @return eql_v3.double_ord +CREATE AGGREGATE eql_v3.min(eql_v3.double_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.double_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.double_ord. +--! @param state eql_v3.double_ord +--! @param value eql_v3.double_ord +--! @return eql_v3.double_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.double_ord, value eql_v3.double_ord) +RETURNS 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 eql_v3.double_ord. +--! @param input eql_v3.double_ord +--! @return eql_v3.double_ord +CREATE AGGREGATE eql_v3.max(eql_v3.double_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.double_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_operators.sql +--! @brief Operators for eql_v3.double. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.double, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.double, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.double, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.double, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.double, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.double, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.double, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.double, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.double, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.double, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.double, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.double, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.double, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.double, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.double, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.double, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.double, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.double, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.double, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.double, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.double, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.double +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_eq_operators.sql +--! @brief Operators for eql_v3.double_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.double_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.double_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.double_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.double_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.double_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.double_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.double_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ore_aggregates.sql +--! @brief Aggregates for eql_v3.date_ord_ore. + +--! @brief State function for min on eql_v3.date_ord_ore. +--! @param state eql_v3.date_ord_ore +--! @param value eql_v3.date_ord_ore +--! @return eql_v3.date_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.date_ord_ore, value eql_v3.date_ord_ore) +RETURNS 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 min aggregate for eql_v3.date_ord_ore. +--! @param input eql_v3.date_ord_ore +--! @return eql_v3.date_ord_ore +CREATE AGGREGATE eql_v3.min(eql_v3.date_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.date_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.date_ord_ore. +--! @param state eql_v3.date_ord_ore +--! @param value eql_v3.date_ord_ore +--! @return eql_v3.date_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.date_ord_ore, value eql_v3.date_ord_ore) +RETURNS 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 max aggregate for eql_v3.date_ord_ore. +--! @param input eql_v3.date_ord_ore +--! @return eql_v3.date_ord_ore +CREATE AGGREGATE eql_v3.max(eql_v3.date_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.date_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ope_aggregates.sql +--! @brief Aggregates for eql_v3.date_ord_ope. + +--! @brief State function for min on eql_v3.date_ord_ope. +--! @param state eql_v3.date_ord_ope +--! @param value eql_v3.date_ord_ope +--! @return eql_v3.date_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.date_ord_ope, value eql_v3.date_ord_ope) +RETURNS 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 min aggregate for eql_v3.date_ord_ope. +--! @param input eql_v3.date_ord_ope +--! @return eql_v3.date_ord_ope +CREATE AGGREGATE eql_v3.min(eql_v3.date_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.date_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.date_ord_ope. +--! @param state eql_v3.date_ord_ope +--! @param value eql_v3.date_ord_ope +--! @return eql_v3.date_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.date_ord_ope, value eql_v3.date_ord_ope) +RETURNS 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 max aggregate for eql_v3.date_ord_ope. +--! @param input eql_v3.date_ord_ope +--! @return eql_v3.date_ord_ope +CREATE AGGREGATE eql_v3.max(eql_v3.date_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.date_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_aggregates.sql +--! @brief Aggregates for eql_v3.date_ord. + +--! @brief State function for min on eql_v3.date_ord. +--! @param state eql_v3.date_ord +--! @param value eql_v3.date_ord +--! @return eql_v3.date_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.date_ord, value eql_v3.date_ord) +RETURNS 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 min aggregate for eql_v3.date_ord. +--! @param input eql_v3.date_ord +--! @return eql_v3.date_ord +CREATE AGGREGATE eql_v3.min(eql_v3.date_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.date_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.date_ord. +--! @param state eql_v3.date_ord +--! @param value eql_v3.date_ord +--! @return eql_v3.date_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.date_ord, value eql_v3.date_ord) +RETURNS 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 max aggregate for eql_v3.date_ord. +--! @param input eql_v3.date_ord +--! @return eql_v3.date_ord +CREATE AGGREGATE eql_v3.max(eql_v3.date_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.date_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_operators.sql +--! @brief Operators for eql_v3.date. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.date, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.date, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.date, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.date, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.date, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.date, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.date, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.date, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.date, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.date, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.date, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.date, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.date, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.date, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.date, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.date, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.date, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.date, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.date, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.date, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.date, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_eq_operators.sql +--! @brief Operators for eql_v3.date_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.date_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.date_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.date_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.date_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.date_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/boolean/boolean_operators.sql +--! @brief Operators for eql_v3.boolean. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.boolean, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.boolean, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.boolean, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.boolean, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.boolean, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.boolean, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.boolean, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.boolean, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.boolean, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.boolean, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.boolean, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.boolean, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.boolean, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.boolean, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.boolean, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.boolean +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ore_aggregates.sql +--! @brief Aggregates for eql_v3.bigint_ord_ore. + +--! @brief State function for min on eql_v3.bigint_ord_ore. +--! @param state eql_v3.bigint_ord_ore +--! @param value eql_v3.bigint_ord_ore +--! @return eql_v3.bigint_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.bigint_ord_ore, value eql_v3.bigint_ord_ore) +RETURNS 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 eql_v3.bigint_ord_ore. +--! @param input eql_v3.bigint_ord_ore +--! @return eql_v3.bigint_ord_ore +CREATE AGGREGATE eql_v3.min(eql_v3.bigint_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.bigint_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.bigint_ord_ore. +--! @param state eql_v3.bigint_ord_ore +--! @param value eql_v3.bigint_ord_ore +--! @return eql_v3.bigint_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.bigint_ord_ore, value eql_v3.bigint_ord_ore) +RETURNS 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 eql_v3.bigint_ord_ore. +--! @param input eql_v3.bigint_ord_ore +--! @return eql_v3.bigint_ord_ore +CREATE AGGREGATE eql_v3.max(eql_v3.bigint_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = 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 eql_v3.bigint_ord_ope. + +--! @brief State function for min on eql_v3.bigint_ord_ope. +--! @param state eql_v3.bigint_ord_ope +--! @param value eql_v3.bigint_ord_ope +--! @return eql_v3.bigint_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.bigint_ord_ope, value eql_v3.bigint_ord_ope) +RETURNS 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 eql_v3.bigint_ord_ope. +--! @param input eql_v3.bigint_ord_ope +--! @return eql_v3.bigint_ord_ope +CREATE AGGREGATE eql_v3.min(eql_v3.bigint_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.bigint_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.bigint_ord_ope. +--! @param state eql_v3.bigint_ord_ope +--! @param value eql_v3.bigint_ord_ope +--! @return eql_v3.bigint_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.bigint_ord_ope, value eql_v3.bigint_ord_ope) +RETURNS 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 eql_v3.bigint_ord_ope. +--! @param input eql_v3.bigint_ord_ope +--! @return eql_v3.bigint_ord_ope +CREATE AGGREGATE eql_v3.max(eql_v3.bigint_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = 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 eql_v3.bigint_ord. + +--! @brief State function for min on eql_v3.bigint_ord. +--! @param state eql_v3.bigint_ord +--! @param value eql_v3.bigint_ord +--! @return eql_v3.bigint_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.bigint_ord, value eql_v3.bigint_ord) +RETURNS 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 min aggregate for eql_v3.bigint_ord. +--! @param input eql_v3.bigint_ord +--! @return eql_v3.bigint_ord +CREATE AGGREGATE eql_v3.min(eql_v3.bigint_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.bigint_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.bigint_ord. +--! @param state eql_v3.bigint_ord +--! @param value eql_v3.bigint_ord +--! @return eql_v3.bigint_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.bigint_ord, value eql_v3.bigint_ord) +RETURNS 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 max aggregate for eql_v3.bigint_ord. +--! @param input eql_v3.bigint_ord +--! @return eql_v3.bigint_ord +CREATE AGGREGATE eql_v3.max(eql_v3.bigint_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.bigint_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_operators.sql +--! @brief Operators for eql_v3.bigint. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.bigint, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.bigint, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.bigint, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.bigint, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.bigint, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.bigint, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.bigint, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.bigint, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.bigint, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.bigint, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.bigint, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.bigint, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_eq_operators.sql +--! @brief Operators for eql_v3.bigint_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq +); + +--! @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 types `eql_v3_internal.ore_block_256`, `eql_v3_internal.ore_cllw`) 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 + -- All operators where at least one operand is an `eql_v3` type. 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())) + ) + ), + + -- 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 + ), + + -- 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 `eql_v3` 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 pg_catalog.pg_type dt ON dt.oid = arg.typ + JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace + JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype + WHERE dt.typtype = 'd' + AND bt.typname = 'jsonb' + AND dn.nspname = ANY(eql_v3_internal.owned_schemas()) + ) + ) + + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ 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). │ + -- └─────────────────────────────────────────────────────────────────┘ + + 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 + ) + + UNION ALL + + 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 + ) + + UNION ALL + + 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 + ) + + UNION ALL + + 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 + ) + + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ 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. │ + -- └─────────────────────────────────────────────────────────────────┘ + + UNION ALL + + 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 + ) + + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ 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. │ + -- └─────────────────────────────────────────────────────────────────┘ + + UNION ALL + + 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' + + UNION ALL + + 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 + + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ 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. │ + -- └─────────────────────────────────────────────────────────────────┘ + + UNION ALL + + 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 bn.nspname = ANY(eql_v3_internal.owned_schemas()) + + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ 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. │ + -- └─────────────────────────────────────────────────────────────────┘ + + UNION ALL + + 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.typtype = 'd' + AND tn.nspname = ANY(eql_v3_internal.owned_schemas()) + + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ 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. │ + -- └─────────────────────────────────────────────────────────────────┘ + + UNION ALL + + 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') + + ORDER BY 1, 2, 3; +$$; + +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.'; + +--! @file v3/jsonb/operators.sql +--! @brief Operators on eql_v3.json and eql_v3.jsonb_entry. + +------------------------------------------------------------------------------ +-- -> field accessor (returns jsonb_entry) +------------------------------------------------------------------------------ + +--! @brief -> operator with text selector. +--! +--! Returns the sv entry whose `s` equals @p selector, with root `i`/`v` merged +--! in. Inlinable: `WHERE col -> 'sel' = $1` reduces structurally to +--! `eql_v3.eq_term(col -> 'sel') = eql_v3.eq_term($1)` and matches a functional +--! index on `eql_v3.eq_term(col -> 'sel')`. +--! +--! @warning The selector operand MUST carry a known type — a text-typed +--! 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 `eql_v3.json` +--! 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 eql_v3.json Root encrypted payload. +--! @param selector text Selector hash. +--! @return eql_v3.jsonb_entry Matching entry merged with root meta, or NULL. +CREATE FUNCTION eql_v3."->"(e eql_v3.json, selector text) + RETURNS eql_v3.jsonb_entry + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT ( + eql_v3.meta_data(e) || + jsonb_path_query_first( + e, + '$.sv[*] ? (@.s == $sel)'::jsonpath, + jsonb_build_object('sel', selector) + ) + )::eql_v3.jsonb_entry +$$; + +CREATE OPERATOR ->( + FUNCTION=eql_v3."->", + LEFTARG=eql_v3.json, + RIGHTARG=text +); + +--! @brief -> operator with integer array index (0-based, JSONB convention). +--! @param e eql_v3.json Encrypted sv-array payload. +--! @param selector integer Array index. +--! @return eql_v3.jsonb_entry Matching entry merged with root meta, or NULL. +CREATE FUNCTION eql_v3."->"(e eql_v3.json, selector integer) + RETURNS eql_v3.jsonb_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 `eql_v3.json` to + -- its base type and binds native `jsonb -> text` (see the @warning above) — + -- the custom `->(eql_v3.json, 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 `->(eql_v3.json, integer)` + -- operator instead of native array access. + (eql_v3.meta_data(e) || (e::jsonb -> 'sv' -> selector))::eql_v3.jsonb_entry + ELSE NULL + END +$$; + +CREATE OPERATOR ->( + FUNCTION=eql_v3."->", + LEFTARG=eql_v3.json, + RIGHTARG=integer +); + +------------------------------------------------------------------------------ +-- ->> field accessor (alias of -> coerced to text) +------------------------------------------------------------------------------ + +--! @brief ->> operator with text selector. Inlinable alias of -> coerced to +--! text. +--! +--! 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 eql_v3.json Encrypted payload. +--! @param selector text Field selector hash. +--! @return text The matching entry as text. +CREATE FUNCTION eql_v3."->>"(e eql_v3.json, selector text) + RETURNS text + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3."->"(e, selector)::jsonb::text +$$; + +CREATE OPERATOR ->> ( + FUNCTION=eql_v3."->>", + LEFTARG=eql_v3.json, + RIGHTARG=text +); + +--! @brief ->> operator with integer array index. Inlinable alias of +--! ->(json, integer) coerced to text. +--! @param e eql_v3.json Encrypted sv-array payload. +--! @param selector integer Array index. +--! @return text The matching entry as text. +CREATE FUNCTION eql_v3."->>"(e eql_v3.json, selector integer) + RETURNS text + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3."->"(e, selector)::jsonb::text +$$; + +CREATE OPERATOR ->> ( + FUNCTION=eql_v3."->>", + LEFTARG=eql_v3.json, + RIGHTARG=integer +); + +------------------------------------------------------------------------------ +-- @> containment +------------------------------------------------------------------------------ + +--! @brief @> contains operator (document, document). +--! @param a eql_v3.json Container. +--! @param b eql_v3.json Contained value. +--! @return boolean True if a contains b. +--! @see eql_v3.ste_vec_contains +CREATE FUNCTION eql_v3."@>"(a eql_v3.json, b eql_v3.json) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ste_vec_contains(a, b) +$$; + +CREATE OPERATOR @>( + FUNCTION=eql_v3."@>", + LEFTARG=eql_v3.json, + RIGHTARG=eql_v3.json +); + +--! @brief @> contains operator with an jsonb_query 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 eql_v3.json Container. +--! @param b eql_v3.jsonb_query Query payload. +--! @return boolean True if a contains b. +CREATE FUNCTION eql_v3."@>"(a eql_v3.json, b eql_v3.jsonb_query) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.to_ste_vec_query(a)::jsonb @> b::jsonb +$$; + +CREATE OPERATOR @>( + FUNCTION=eql_v3."@>", + LEFTARG=eql_v3.json, + RIGHTARG=eql_v3.jsonb_query +); + +--! @brief @> contains operator with a single jsonb_entry needle. +--! +--! 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 eql_v3.json Container. +--! @param b eql_v3.jsonb_entry Single entry. +--! @return boolean True if a contains an sv entry matching b. +CREATE FUNCTION eql_v3."@>"(a eql_v3.json, b eql_v3.jsonb_entry) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.to_ste_vec_query(a)::jsonb + @> jsonb_build_object( + 'sv', + jsonb_build_array( + jsonb_strip_nulls( + jsonb_build_object( + 's', b -> 's', + 'hm', b -> 'hm', + 'oc', b -> 'oc' + ) + ) + ) + ) +$$; + +CREATE OPERATOR @>( + FUNCTION=eql_v3."@>", + LEFTARG=eql_v3.json, + RIGHTARG=eql_v3.jsonb_entry +); + +------------------------------------------------------------------------------ +-- <@ contained-by (reverse of @>) +------------------------------------------------------------------------------ + +--! @brief <@ contained-by operator (document, document). +--! @param a eql_v3.json Contained value. +--! @param b eql_v3.json Container. +--! @return boolean True if a is contained by b. +CREATE FUNCTION eql_v3."<@"(a eql_v3.json, b eql_v3.json) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ste_vec_contains(b, a) +$$; + +CREATE OPERATOR <@( + FUNCTION=eql_v3."<@", + LEFTARG=eql_v3.json, + RIGHTARG=eql_v3.json +); + +--! @brief <@ contained-by operator with an jsonb_query LHS. +--! @param a eql_v3.jsonb_query Query payload. +--! @param b eql_v3.json Container. +--! @return boolean True if b contains a. +CREATE FUNCTION eql_v3."<@"(a eql_v3.jsonb_query, b eql_v3.json) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3."@>"(b, a) +$$; + +CREATE OPERATOR <@( + FUNCTION=eql_v3."<@", + LEFTARG=eql_v3.jsonb_query, + RIGHTARG=eql_v3.json +); + +--! @brief <@ contained-by operator with a jsonb_entry LHS. +--! @param a eql_v3.jsonb_entry Single entry. +--! @param b eql_v3.json Container. +--! @return boolean True if b contains a. +CREATE FUNCTION eql_v3."<@"(a eql_v3.jsonb_entry, b eql_v3.json) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3."@>"(b, a) +$$; + +CREATE OPERATOR <@( + FUNCTION=eql_v3."<@", + LEFTARG=eql_v3.jsonb_entry, + RIGHTARG=eql_v3.json +); + +------------------------------------------------------------------------------ +-- jsonb_entry comparisons +------------------------------------------------------------------------------ + +--! @brief Equality on jsonb_entry via eq_term (hm-or-oc byte equality). +--! @param a eql_v3.jsonb_entry Left operand +--! @param b eql_v3.jsonb_entry Right operand +--! @return boolean True if the entries are equal +CREATE FUNCTION eql_v3.eq(a eql_v3.jsonb_entry, b eql_v3.jsonb_entry) + 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.jsonb_entry, + RIGHTARG = eql_v3.jsonb_entry, + COMMUTATOR = =, + NEGATOR = <>, + RESTRICT = eqsel, + JOIN = eqjoinsel +); + +--! @brief Inequality on jsonb_entry via eq_term. +--! @param a eql_v3.jsonb_entry Left operand +--! @param b eql_v3.jsonb_entry Right operand +--! @return boolean True if the entries are not equal +CREATE FUNCTION eql_v3.neq(a eql_v3.jsonb_entry, b eql_v3.jsonb_entry) + 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.jsonb_entry, + RIGHTARG = eql_v3.jsonb_entry, + COMMUTATOR = <>, + NEGATOR = =, + RESTRICT = neqsel, + JOIN = neqjoinsel +); + +--! @brief Less-than on jsonb_entry via ore_cllw. +--! @param a eql_v3.jsonb_entry Left operand +--! @param b eql_v3.jsonb_entry Right operand +--! @return boolean True if a is less than b +CREATE FUNCTION eql_v3.lt(a eql_v3.jsonb_entry, b eql_v3.jsonb_entry) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ore_cllw(a) < eql_v3.ore_cllw(b) +$$; + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.jsonb_entry, + RIGHTARG = eql_v3.jsonb_entry, + COMMUTATOR = >, + NEGATOR = >=, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel +); + +--! @brief Less-than-or-equal on jsonb_entry via ore_cllw. +--! @param a eql_v3.jsonb_entry Left operand +--! @param b eql_v3.jsonb_entry Right operand +--! @return boolean True if a is less than or equal to b +CREATE FUNCTION eql_v3.lte(a eql_v3.jsonb_entry, b eql_v3.jsonb_entry) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ore_cllw(a) <= eql_v3.ore_cllw(b) +$$; + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.jsonb_entry, + RIGHTARG = eql_v3.jsonb_entry, + COMMUTATOR = >=, + NEGATOR = >, + RESTRICT = scalarlesel, + JOIN = scalarlejoinsel +); + +--! @brief Greater-than on jsonb_entry via ore_cllw. +--! @param a eql_v3.jsonb_entry Left operand +--! @param b eql_v3.jsonb_entry Right operand +--! @return boolean True if a is greater than b +CREATE FUNCTION eql_v3.gt(a eql_v3.jsonb_entry, b eql_v3.jsonb_entry) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ore_cllw(a) > eql_v3.ore_cllw(b) +$$; + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.jsonb_entry, + RIGHTARG = eql_v3.jsonb_entry, + COMMUTATOR = <, + NEGATOR = <=, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel +); + +--! @brief Greater-than-or-equal on jsonb_entry via ore_cllw. +--! @param a eql_v3.jsonb_entry Left operand +--! @param b eql_v3.jsonb_entry Right operand +--! @return boolean True if a is greater than or equal to b +CREATE FUNCTION eql_v3.gte(a eql_v3.jsonb_entry, b eql_v3.jsonb_entry) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ore_cllw(a) >= eql_v3.ore_cllw(b) +$$; + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.jsonb_entry, + RIGHTARG = eql_v3.jsonb_entry, + COMMUTATOR = <=, + NEGATOR = <, + RESTRICT = scalargesel, + JOIN = scalargejoinsel +); + +--! @file v3/jsonb/blockers.sql +--! @brief Native-jsonb firewall for eql_v3.json. +--! +--! eql_v3.json SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons +--! = <> < <= > >= are supported on eql_v3.jsonb_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 +--! route to plaintext-jsonb semantics. The blocked set is KNOWN_JSONB_OPERATORS +--! minus the supported ops: ? ?| ?& @? @@ #> #>> - #- ||. +--! +--! Each blocker is LANGUAGE plpgsql (NEVER STRICT — a STRICT blocker would let +--! PostgreSQL skip the body and return NULL on a NULL argument, bypassing the +--! exception) and delegates to the shared eql_v3.encrypted_domain_unsupported_* +--! helpers. Each blocker's RETURNS type matches the native operator it shadows +--! (#> -> jsonb, #>> -> text, - / #- / || -> jsonb; the rest are boolean) so a +--! composed expression resolves and the body raises 'operator not supported', +--! rather than failing earlier with a misleading 'operator does not exist' on a +--! boolean intermediate. The bound operator must resolve before native fallback, +--! so the firewall fires. + +--! @brief Blocker: ? (key/element exists). +--! @param a eql_v3.json 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 eql_v3.json, b text) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '?'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal.jsonb_blocked_exists, + LEFTARG = eql_v3.json, + RIGHTARG = text +); + +--! @brief Blocker: ?| (any key exists). +--! @param a eql_v3.json 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 eql_v3.json, b text[]) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '?|'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal.jsonb_blocked_exists_any, + LEFTARG = eql_v3.json, + RIGHTARG = text[] +); + +--! @brief Blocker: ?& (all keys exist). +--! @param a eql_v3.json 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 eql_v3.json, b text[]) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '?&'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal.jsonb_blocked_exists_all, + LEFTARG = eql_v3.json, + RIGHTARG = text[] +); + +--! @brief Blocker: @? (jsonpath exists). +--! @param a eql_v3.json 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 eql_v3.json, b jsonpath) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '@?'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_exists, + LEFTARG = eql_v3.json, + RIGHTARG = jsonpath +); + +--! @brief Blocker: @@ (jsonpath predicate). +--! @param a eql_v3.json 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 eql_v3.json, b jsonpath) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '@@'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_match, + LEFTARG = eql_v3.json, + RIGHTARG = jsonpath +); + +--! @brief Blocker: #> (path extract, native returns jsonb). +--! @param a eql_v3.json 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 eql_v3.json, b text[]) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '#>'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal.jsonb_blocked_path_extract, + LEFTARG = eql_v3.json, + RIGHTARG = text[] +); + +--! @brief Blocker: #>> (path extract as text). +--! @param a eql_v3.json 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 eql_v3.json, b text[]) +RETURNS text +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_text('eql_v3.json', '#>>'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal.jsonb_blocked_path_extract_text, + LEFTARG = eql_v3.json, + RIGHTARG = text[] +); + +--! @brief Blocker: - (delete key, text RHS; native returns jsonb). +--! @param a eql_v3.json 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 eql_v3.json, b text) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '-'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal.jsonb_blocked_delete_text, + LEFTARG = eql_v3.json, + RIGHTARG = text +); + +--! @brief Blocker: - (delete index, integer RHS). +--! @param a eql_v3.json 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 eql_v3.json, b integer) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '-'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal.jsonb_blocked_delete_int, + LEFTARG = eql_v3.json, + RIGHTARG = integer +); + +--! @brief Blocker: - (delete keys, text[] RHS). +--! @param a eql_v3.json 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 eql_v3.json, b text[]) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '-'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal.jsonb_blocked_delete_array, + LEFTARG = eql_v3.json, + RIGHTARG = text[] +); + +--! @brief Blocker: #- (delete at path). +--! @param a eql_v3.json 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 eql_v3.json, b text[]) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '#-'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal.jsonb_blocked_delete_path, + LEFTARG = eql_v3.json, + RIGHTARG = text[] +); + +--! @brief Blocker: || (concatenate, encrypted on the left). +--! @param a eql_v3.json 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 eql_v3.json, b jsonb) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '||'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal.jsonb_blocked_concat, + LEFTARG = eql_v3.json, + RIGHTARG = jsonb +); + +--! @brief Blocker: || (concatenate, encrypted on the right). +--! @param a jsonb Native LHS operand. +--! @param b eql_v3.json 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 eql_v3.json) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '||'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal.jsonb_blocked_concat_rhs, + LEFTARG = jsonb, + RIGHTARG = eql_v3.json +); + +------------------------------------------------------------------------------ +-- Root-document comparison blockers. +------------------------------------------------------------------------------ + +--! @brief Blocker: root eql_v3.json document comparisons. +--! @param a eql_v3.json Left operand (encrypted payload). +--! @param b eql_v3.json Right operand (encrypted payload). +--! @return boolean Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_json(a eql_v3.json, b eql_v3.json) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', 'comparison'); +END; +$$ LANGUAGE plpgsql; + +--! @brief Blocker: root eql_v3.json-to-jsonb comparisons. +--! @param a eql_v3.json 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 eql_v3.json, b jsonb) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', 'comparison'); +END; +$$ LANGUAGE plpgsql; + +--! @brief Blocker: root jsonb-to-eql_v3.json comparisons. +--! @param a jsonb Native LHS operand. +--! @param b eql_v3.json 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 eql_v3.json) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', 'comparison'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, + LEFTARG = eql_v3.json, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = eql_v3.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, + LEFTARG = eql_v3.json, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = eql_v3.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, + LEFTARG = eql_v3.json, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = eql_v3.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, + LEFTARG = eql_v3.json, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = eql_v3.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, + LEFTARG = eql_v3.json, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = eql_v3.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, + LEFTARG = eql_v3.json, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = eql_v3.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = eql_v3.json +); + +------------------------------------------------------------------------------ +-- Mixed jsonb containment blockers. +------------------------------------------------------------------------------ + +--! @brief Blocker: @> with encrypted root document and native jsonb. +--! @param a eql_v3.json 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 eql_v3.json, b jsonb) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '@>'); +END; +$$ LANGUAGE plpgsql; + +--! @brief Blocker: @> with native jsonb and encrypted root document. +--! @param a jsonb Native LHS operand. +--! @param b eql_v3.json 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 eql_v3.json) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '@>'); +END; +$$ LANGUAGE plpgsql; + +--! @brief Blocker: <@ with encrypted root document and native jsonb. +--! @param a eql_v3.json 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 eql_v3.json, b jsonb) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '<@'); +END; +$$ LANGUAGE plpgsql; + +--! @brief Blocker: <@ with native jsonb and encrypted root document. +--! @param a jsonb Native LHS operand. +--! @param b eql_v3.json 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 eql_v3.json) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '<@'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.jsonb_blocked_contains_json_jsonb, + LEFTARG = eql_v3.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.jsonb_blocked_contains_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.jsonb_blocked_contained_json_jsonb, + LEFTARG = eql_v3.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.jsonb_blocked_contained_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = eql_v3.json +); + +--! @file v3/jsonb/aggregates.sql +--! @brief min / max aggregates over eql_v3.jsonb_entry. +--! +--! SteVec document entries extracted at a selector (`doc -> 'sel'`) order by +--! their CLLW ORE (`oc`) term, so the extremum is picked by comparing +--! `eql_v3.ore_cllw(entry)` rather than the scalar Block-ORE `ord_term` the +--! generated scalar ord aggregates use. 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 `oc`-carrying entries are orderable.** `eql_v3.ore_cllw(entry)` +--! returns NULL when an entry has no `oc` (CLLW ORE) term — the same entries a +--! `eql_v3.ore_cllw` btree NULL-filters from range scans. The state functions +--! therefore IGNORE `oc`-less entries (they never become or survive as the +--! extremum), so `min`/`max` is well-defined over a mix of `oc`-carrying and +--! `oc`-less entries and is not corrupted by an `oc`-less seed. A naive +--! `ore_cllw(value) < ore_cllw(state)` would be NULL whenever either side +--! lacks `oc`, pinning a wrong (`oc`-less) extremum when the first aggregated +--! row is `oc`-less. An all-`oc`-less input has no orderable extremum and +--! returns the (arbitrary) STRICT seed. + +--! @brief State function for min on eql_v3.jsonb_entry. +--! +--! Keeps whichever orderable entry has the lesser CLLW ORE term. STRICT, so SQL +--! NULL entries are skipped by the aggregate machinery; `oc`-less (non-orderable) +--! entries are skipped explicitly (see the @note on this file). +--! +--! @param state eql_v3.jsonb_entry Running extremum. +--! @param value eql_v3.jsonb_entry Candidate entry. +--! @return eql_v3.jsonb_entry The lesser orderable entry by `ore_cllw`. +CREATE FUNCTION eql_v3_internal.jsonb_entry_min_sfunc( + state eql_v3.jsonb_entry, + value eql_v3.jsonb_entry +) +RETURNS eql_v3.jsonb_entry +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +DECLARE + value_ore eql_v3_internal.ore_cllw := eql_v3.ore_cllw(value); + state_ore eql_v3_internal.ore_cllw := eql_v3.ore_cllw(state); +BEGIN + -- A non-orderable (oc-less) candidate never replaces the running extremum. + IF value_ore IS NULL THEN + RETURN state; + END IF; + -- Adopt the candidate when the running extremum is itself non-orderable + -- (e.g. an oc-less STRICT seed) or strictly greater. + IF state_ore IS NULL OR value_ore < state_ore THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate over eql_v3.jsonb_entry. +--! @param input eql_v3.jsonb_entry +--! @return eql_v3.jsonb_entry The entry with the smallest CLLW ORE term. +CREATE AGGREGATE eql_v3.min(eql_v3.jsonb_entry) ( + sfunc = eql_v3_internal.jsonb_entry_min_sfunc, + stype = eql_v3.jsonb_entry, + combinefunc = eql_v3_internal.jsonb_entry_min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.jsonb_entry. +--! +--! Keeps whichever orderable entry has the greater CLLW ORE term. `oc`-less +--! entries are skipped, mirroring `jsonb_entry_min_sfunc` (see the file @note). +--! +--! @param state eql_v3.jsonb_entry Running extremum. +--! @param value eql_v3.jsonb_entry Candidate entry. +--! @return eql_v3.jsonb_entry The greater orderable entry by `ore_cllw`. +CREATE FUNCTION eql_v3_internal.jsonb_entry_max_sfunc( + state eql_v3.jsonb_entry, + value eql_v3.jsonb_entry +) +RETURNS eql_v3.jsonb_entry +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +DECLARE + value_ore eql_v3_internal.ore_cllw := eql_v3.ore_cllw(value); + state_ore eql_v3_internal.ore_cllw := eql_v3.ore_cllw(state); +BEGIN + -- A non-orderable (oc-less) candidate never replaces the running extremum. + IF value_ore IS NULL THEN + RETURN state; + END IF; + -- Adopt the candidate when the running extremum is itself non-orderable + -- (e.g. an oc-less STRICT seed) or strictly lesser. + IF state_ore IS NULL OR value_ore > state_ore THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate over eql_v3.jsonb_entry. +--! @param input eql_v3.jsonb_entry +--! @return eql_v3.jsonb_entry The entry with the largest CLLW ORE term. +CREATE AGGREGATE eql_v3.max(eql_v3.jsonb_entry) ( + sfunc = eql_v3_internal.jsonb_entry_max_sfunc, + stype = eql_v3.jsonb_entry, + combinefunc = eql_v3_internal.jsonb_entry_max_sfunc, + parallel = safe +); +--! @file pin_search_path_v3.sql +--! @brief Post-install: pin search_path on every eql_v3.* function. +--! +--! Appended verbatim by `tasks/build.sh` to the end of the v3-only release +--! artifact, AFTER all src/v3/**/*.sql files have been concatenated. It lives +--! outside src/ so it stays out of the dependency graph. +--! +--! Iterates over functions in the `eql_v3` and `eql_v3_internal` schemas and +--! applies a fixed `search_path` via `ALTER FUNCTION ... SET search_path = ...`, +--! satisfying Supabase splinter's `function_search_path_mutable` lint. +--! +--! @note A SET clause disables SQL-function inlining. The inline-critical SEM +--! helpers (ore_block_256_*, ore_cllw_*, ore_cllw/has_ore_cllw, +--! ope_cllw, hmac_256, bloom_filter over jsonb) and the +--! encrypted-domain family (recognised structurally) are deliberately +--! left unpinned. +--! @see tasks/test/splinter.sh +--! @see tasks/build.sh + +DO $$ +DECLARE + fn_oid oid; + inline_critical_oids oid[]; + jsonb_oid oid; +BEGIN + SELECT t.oid INTO jsonb_oid + FROM pg_catalog.pg_type t + JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace + WHERE n.nspname = 'pg_catalog' AND t.typname = 'jsonb'; + + IF jsonb_oid IS NULL THEN + RAISE EXCEPTION 'pin_search_path_v3: type pg_catalog.jsonb not found'; + END IF; + + -- eql_v3 SEM index-term functions that must stay inlinable for + -- functional-index matching (no SET, IMMUTABLE). Mirrors the eql_v3 clause + -- in the legacy combined pin_search_path.sql. + SELECT pg_catalog.array_agg(p.oid) INTO inline_critical_oids + FROM pg_catalog.pg_proc p + JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace + WHERE n.nspname = ANY(eql_v3_internal.owned_schemas()) + AND ( + (p.pronargs = 2 + AND p.proname IN ('ore_block_256_eq', 'ore_block_256_neq', + 'ore_block_256_lt', 'ore_block_256_lte', + 'ore_block_256_gt', 'ore_block_256_gte')) + OR (p.pronargs = 2 + AND p.proname IN ('ore_cllw_eq', 'ore_cllw_neq', + 'ore_cllw_lt', 'ore_cllw_lte', + 'ore_cllw_gt', 'ore_cllw_gte')) + OR (p.pronargs = 1 + AND p.proname IN ('ore_cllw', 'has_ore_cllw') + AND p.proargtypes[0] = jsonb_oid) + -- The CLLW-OPE surface is the extractor alone: eql_v3_internal.ope_cllw is a + -- domain over bytea (native comparison operators and btree opclass), + -- so there are no ope-specific comparison functions to keep inlinable. + OR (p.pronargs = 1 + AND p.proname = 'ope_cllw' + AND p.proargtypes[0] = jsonb_oid) + OR (p.pronargs = 1 + AND p.proname = 'hmac_256' + AND p.proargtypes[0] = jsonb_oid) + OR (p.pronargs = 1 + AND p.proname = 'bloom_filter' + AND p.proargtypes[0] = jsonb_oid) + ); + + FOR fn_oid IN + SELECT p.oid + FROM pg_catalog.pg_proc p + JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace + WHERE n.nspname = ANY(eql_v3_internal.owned_schemas()) + AND p.prokind IN ('f', 'w') + AND NOT EXISTS ( + SELECT 1 FROM pg_catalog.unnest(coalesce(p.proconfig, '{}'::text[])) c + WHERE c LIKE 'search_path=%' + ) + AND NOT (p.oid = ANY (coalesce(inline_critical_oids, '{}'::oid[]))) + -- Encrypted-domain family — structural skip: LANGUAGE sql, IMMUTABLE, + -- taking >=1 argument typed as a jsonb-backed DOMAIN in eql_v3. + AND NOT ( + p.prolang = (SELECT l.oid FROM pg_catalog.pg_language l + WHERE l.lanname = 'sql') + AND p.provolatile = 'i' + AND EXISTS ( + SELECT 1 + FROM pg_catalog.unnest(p.proargtypes::oid[]) AS arg(typ) + JOIN pg_catalog.pg_type dt ON dt.oid = arg.typ + JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace + WHERE dt.typtype = 'd' + AND dt.typbasetype = jsonb_oid + AND dn.nspname = ANY(eql_v3_internal.owned_schemas()) + ) + ) + -- Comment-marker fallback for hand-written inline-critical extension + -- functions that take no domain argument. + AND NOT EXISTS ( + SELECT 1 FROM pg_catalog.pg_description d + WHERE d.objoid = p.oid + AND d.classoid = 'pg_catalog.pg_proc'::regclass + AND d.description LIKE 'eql-inline-critical%' + ) + LOOP + EXECUTE pg_catalog.format( + 'ALTER FUNCTION %s SET search_path = pg_catalog, extensions, public', + fn_oid::regprocedure + ); + END LOOP; +END $$; diff --git a/packages/cli/src/sql/cipherstash-encrypt-v3.sql b/packages/cli/src/sql/cipherstash-encrypt-v3.sql new file mode 100644 index 00000000..08da1ff8 --- /dev/null +++ b/packages/cli/src/sql/cipherstash-encrypt-v3.sql @@ -0,0 +1,36278 @@ +--! @file v3/schema.sql +--! @brief EQL v3 schema creation +--! +--! Creates the eql_v3 and eql_v3_internal schemas. eql_v3 is the public API: +--! the self-contained encrypted-domain type families (eql_v3.integer, eql_v3.bigint, +--! and future scalar domains) — their jsonb-backed domains, index-term +--! extractors, aggregates, AND the operator-backing comparison wrappers +--! (eq/neq/lt/lte/gt/gte/contains/contained_by, plus the jsonb containment +--! helpers). The wrappers are public because they are the function-form +--! equivalent of every supported operator: platforms without operator support +--! (Supabase/PostgREST calls functions, not operators) invoke them by name. +--! eql_v3_internal houses INTERNAL implementation objects only: the +--! searchable-encrypted-metadata (SEM) index-term types +--! (eql_v3_internal.hmac_256, eql_v3_internal.ore_block_256) and their support +--! functions, the unsupported-operator blockers (which only raise), and the +--! aggregate state functions. Together the two schemas are self-contained — +--! they own every type they need and have no runtime dependency on another EQL +--! schema. +--! +--! Drops existing schema if present to support clean reinstallation. +--! +--! @warning DROP SCHEMA CASCADE will remove all objects in the schema +--! @note eql_v3 is a new, additional schema for the encrypted-domain families. +--! +--! @note DESIGN DECISION — EQL never grants permissions automatically. This +--! installer issues no GRANT (or REVOKE) on eql_v3 or eql_v3_internal: +--! access is strictly opt-in. A deployment that exposes EQL to +--! non-owner roles (e.g. Supabase `authenticated`/`anon` via PostgREST) +--! must explicitly `GRANT USAGE ON SCHEMA eql_v3` and `GRANT EXECUTE` on +--! the functions it needs. This is intentional least-privilege, not an +--! oversight — see docs/reference/permissions.md. eql_v3_internal is not +--! part of the public API and normally needs no grant; where a caller +--! reaches an internal object indirectly (a public operator/aggregate +--! whose backing state-fn/blocker lives there), grant it deliberately. + +--! @brief Drop existing EQL v3 schema +--! @warning CASCADE will drop all dependent objects +DROP SCHEMA IF EXISTS eql_v3 CASCADE; + +--! @brief Create EQL v3 schema +--! @note Houses the encrypted-domain type families +CREATE SCHEMA eql_v3; + +--! @brief Drop existing EQL v3 internal schema +--! @warning CASCADE will drop all dependent objects +DROP SCHEMA IF EXISTS eql_v3_internal CASCADE; + +--! @brief Create EQL v3 internal implementation schema +--! @note Houses INTERNAL eql_v3 objects only: SEM index-term TYPES + their +--! support/constructor/comparator functions, the unsupported-operator +--! blockers (which only raise), the aggregate state functions, and the +--! SteVec CHECK validators. Kept out of the public `eql_v3` surface so +--! internal index-term TYPES do not clutter the Supabase Table Builder +--! type picker. NOTE: the operator-backing comparison *wrappers* are NOT +--! here — they are public in `eql_v3` so every operator has a callable +--! function equivalent for platforms without operator support. +CREATE SCHEMA eql_v3_internal; +COMMENT ON SCHEMA eql_v3_internal IS + 'EQL internal implementation detail; not a public API surface.'; + +--! @brief Schemas owned by the eql_v3 surface +--! +--! Single source of truth for tooling that must enumerate every schema this +--! installer owns (`eql_v3.lints()`, `tasks/pin_search_path_v3.sql`), so a +--! future third eql_v3-family schema is one array literal to edit instead of +--! a hardcoded schema-name predicate repeated at every call site. Keep in +--! sync with the `SCHEMA` / `INTERNAL_SCHEMA` constants in +--! `crates/eql-codegen/src/consts.rs` — those drive what codegen emits into +--! each schema; this drives what tooling scans across both. +--! +--! @return name[] The schema names eql_v3 owns (public + internal). +CREATE FUNCTION eql_v3_internal.owned_schemas() + RETURNS name[] + LANGUAGE sql IMMUTABLE PARALLEL SAFE +AS $$ + SELECT ARRAY['eql_v3', 'eql_v3_internal']::name[] +$$; + +--! @file v3/crypto.sql +--! @brief PostgreSQL pgcrypto extension enablement (eql_v3 fork) +--! +--! Forked from src/crypto.sql (design D8) so the entire eql_v3 dependency +--! closure lives under src/v3/. Enables the pgcrypto extension which provides +--! cryptographic functions used by the eql_v3 ORE comparison path. +--! +--! Installs pgcrypto into the `extensions` schema (Supabase convention) to +--! avoid the `extension_in_public` lint. Every EQL function that uses pgcrypto +--! has `pg_catalog, extensions, public` on its `search_path`, so a pre-existing +--! install in `public` keeps working — and a pre-existing install anywhere else +--! will be rejected at install time. The body is idempotent +--! (`CREATE SCHEMA IF NOT EXISTS`, `pg_extension` guard), so running it +--! alongside the eql_v2 copy in a combined install is safe. +--! +--! @note pgcrypto provides functions like digest(), hmac(), gen_random_bytes() + +--! @brief Create extensions schema (Supabase convention) +CREATE SCHEMA IF NOT EXISTS extensions; + +--! @brief Enable pgcrypto extension and validate its schema +DO $$ +DECLARE + pgcrypto_schema name; +BEGIN + IF NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'pgcrypto') THEN + CREATE EXTENSION pgcrypto WITH SCHEMA extensions; + END IF; + + SELECT n.nspname INTO pgcrypto_schema + FROM pg_extension e + JOIN pg_namespace n ON n.oid = e.extnamespace + WHERE e.extname = 'pgcrypto'; + + IF pgcrypto_schema = 'extensions' THEN + -- expected location, nothing to say + NULL; + ELSIF pgcrypto_schema = 'public' THEN + RAISE NOTICE + 'pgcrypto is installed in the `public` schema. EQL works against this layout, ' + 'but Supabase splinter will flag it as `extension_in_public`. Move it with: ' + 'ALTER EXTENSION pgcrypto SET SCHEMA extensions'; + ELSE + RAISE EXCEPTION + 'pgcrypto is installed in schema `%`, which is not on the EQL function search_path ' + '(pg_catalog, extensions, public). EQL cryptographic operations would fail at ' + 'runtime. Relocate the extension before installing EQL: ' + 'ALTER EXTENSION pgcrypto SET SCHEMA extensions', + pgcrypto_schema; + END IF; +END $$; + +--! @file v3/common.sql +--! @brief Common utility functions for the self-contained eql_v3 surface. +--! +--! Forked from src/common.sql (design D7) so the eql_v3 ORE constructor owns the +--! one transitive helper it needs without reaching into another schema. The +--! eql_v2 original is unchanged. + +--! @brief Convert JSONB hex array to bytea array +--! @internal +--! +--! Converts a JSONB array of hex-encoded strings into a PostgreSQL bytea array. +--! Used for deserializing binary data (like ORE terms) from JSONB storage. +--! +--! @param val jsonb JSONB array of hex-encoded strings +--! @return bytea[] Array of decoded binary values +--! +--! @note Returns NULL if input is JSON null +--! @note Each array element is hex-decoded to bytea +--! @note Inlinable `LANGUAGE sql` IMMUTABLE form (no `SET search_path`) so the +--! planner can fold this per-encrypted-value helper into the calling query. +--! This deliberately diverges from the v2 plpgsql equivalent (intentionally +--! left unchanged): the `CASE WHEN jsonb_typeof(val) = 'array'` guard only +--! evaluates the set-returning `jsonb_array_elements_text` for an array, so a +--! non-array JSON scalar returns NULL here instead of raising "cannot extract +--! elements from a scalar". Both callers only ever pass an array or JSON null +--! (`val->'ob'`), so the divergence is unreachable in practice; JSON null and +--! empty array still return NULL exactly as before. +CREATE FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(val jsonb) +RETURNS bytea[] + IMMUTABLE +AS $$ + SELECT CASE WHEN jsonb_typeof(val) = 'array' + THEN ( + SELECT array_agg(decode(value::text, 'hex')::bytea) + FROM jsonb_array_elements_text(val) AS value + ) + ELSE NULL + END; +$$ LANGUAGE sql; + +--! @internal Mark this hand-written helper inline-critical so the post-install +--! pin_search_path pass leaves it unpinned (no `SET search_path`), preserving +--! SQL-function inlining. It takes a bare `jsonb` arg (not a jsonb-backed +--! encrypted DOMAIN), so the structural skip in tasks/pin_search_path_v3.sql does +--! not recognise it; this marker is the documented manual opt-in. +COMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(jsonb) IS + 'eql-inline-critical: per-encrypted-value ORE helper; must stay inlinable (unpinned search_path)'; + +--! @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/sem/ore_block_256/functions.sql +--! @brief ORE block construction, extraction, and comparison (eql_v3 SEM). +--! +--! jsonb-only subset of src/ore_block_u64_8_256/functions.sql. The +--! encrypted-column overloads are omitted; the helper jsonb_array_to_bytea_array +--! and pgcrypto encrypt() are reached via the forked src/v3/common.sql and +--! src/v3/crypto.sql so the whole closure stays under src/v3. (Doc comments +--! deliberately avoid naming eql_v2 symbols so the self-containment grep stays +--! clean.) + +--! @brief Convert JSONB array to ORE block composite type +--! @internal +--! @param val jsonb Array of hex-encoded ORE block terms +--! @return eql_v3_internal.ore_block_256 ORE block composite, or NULL if input is null +--! @note Inlinable `LANGUAGE sql` IMMUTABLE form (no `SET search_path`) so the +--! planner can fold this per-encrypted-value helper into the calling query. +--! This deliberately diverges from the v2 plpgsql equivalent (intentionally +--! left unchanged): the `CASE WHEN jsonb_typeof(val) = 'array'` guard only +--! evaluates the array path for an array, so a non-array JSON scalar returns +--! NULL here instead of raising. The sole caller (`ore_block_256`) only reaches +--! this when `has_ore_block_256(val)` is true, which now requires `val->'ob'` +--! to be a JSON array, so the non-array branch is unreachable in practice. +--! An empty array (`ob: []`, what encrypting the empty string `""` produces) +--! yields a non-NULL composite with an EMPTY `terms` array — NOT NULL terms. +--! The `COALESCE` is load-bearing: `array_agg` over zero rows returns NULL, and +--! NULL terms make the comparator return NULL (so an empty-text row silently +--! drops out of ordered queries). An empty array instead engages the +--! comparator's `cardinality = 0` guard, which sorts empty BEFORE every +--! non-empty term. See issue #262 (pinned by T7). +CREATE FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(val jsonb) +RETURNS eql_v3_internal.ore_block_256 + IMMUTABLE +AS $$ + SELECT CASE WHEN jsonb_typeof(val) = 'array' + THEN ROW(COALESCE( + ( + SELECT array_agg(ROW(b)::eql_v3_internal.ore_block_256_term) + FROM unnest(eql_v3_internal.jsonb_array_to_bytea_array(val)) AS b + ), + ARRAY[]::eql_v3_internal.ore_block_256_term[] + ))::eql_v3_internal.ore_block_256 + ELSE NULL + END; +$$ LANGUAGE sql; + +--! @internal Mark this hand-written helper inline-critical so the post-install +--! pin_search_path pass leaves it unpinned (no `SET search_path`), preserving +--! SQL-function inlining. It takes a bare `jsonb` arg (not a jsonb-backed +--! encrypted DOMAIN), so the structural skip in tasks/pin_search_path_v3.sql does +--! not recognise it; this marker is the documented manual opt-in. +COMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(jsonb) IS + 'eql-inline-critical: per-encrypted-value ORE helper; must stay inlinable (unpinned search_path)'; + + +--! @brief Extract ORE block index term from JSONB payload +--! @param val jsonb containing encrypted EQL payload +--! @return eql_v3_internal.ore_block_256 ORE block index term +--! @throws Exception if 'ob' field is missing +CREATE FUNCTION eql_v3_internal.ore_block_256(val jsonb) + RETURNS eql_v3_internal.ore_block_256 + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + BEGIN + -- Declared STRICT: PostgreSQL returns NULL for a NULL argument without + -- entering the body, so no explicit `val IS NULL` guard is needed. + IF eql_v3_internal.has_ore_block_256(val) THEN + RETURN eql_v3_internal.jsonb_array_to_ore_block_256(val->'ob'); + END IF; + RAISE 'Expected an ore index (ob) value in json: %', val; + END; +$$ LANGUAGE plpgsql; + + +--! @brief Check if JSONB payload contains an ORE block index term +--! @param val jsonb containing encrypted EQL payload +--! @return boolean True only if the 'ob' field is present and is a JSON array +--! @note A well-formed ORE index term is always a JSON array of block terms, so +--! this guard treats a present-but-non-array `ob` (a scalar or object) as +--! absent. That makes the extractor `ore_block_256(val)` RAISE on a +--! structurally invalid `ob` payload at the boundary instead of silently +--! degrading it to a NULL index term in `jsonb_array_to_ore_block_256`. The +--! previous `val ->> 'ob' IS NOT NULL` form stringified scalars/objects and so +--! reported them as present. `{}` (absent `ob`) and `{"ob": null}` (JSON null) +--! both remain `false`. +CREATE FUNCTION eql_v3_internal.has_ore_block_256(val jsonb) + RETURNS boolean + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + BEGIN + RETURN COALESCE(jsonb_typeof(val -> 'ob') = 'array', false); + END; +$$ LANGUAGE plpgsql; + + +--! @brief Compare two ORE block terms using cryptographic comparison +--! @internal +--! @param a eql_v3_internal.ore_block_256_term First ORE term +--! @param b eql_v3_internal.ore_block_256_term Second ORE term +--! @return integer -1 if a < b, 0 if a = b, 1 if a > b +--! @throws Exception if ciphertexts are different lengths +--! @note Marked `IMMUTABLE` (the three `compare_ore_block_256_term(s)` +--! overloads all are). This deliberately diverges from the v2 originals, +--! which carry no volatility marker and so default to `VOLATILE`. The +--! comparison is deterministic — its only crypto call, pgcrypto `encrypt()`, +--! is itself `IMMUTABLE STRICT PARALLEL SAFE` — so `IMMUTABLE` lets the +--! planner fold/cache these in ordering and index contexts. NOT `STRICT`: +--! the NULL-handling branches below are load-bearing for the array overload. +CREATE FUNCTION eql_v3_internal.compare_ore_block_256_term(a eql_v3_internal.ore_block_256_term, b eql_v3_internal.ore_block_256_term) + RETURNS integer + IMMUTABLE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + eq boolean := true; + unequal_block smallint := 0; + hash_key bytea; + data_block bytea; + encrypt_block bytea; + target_block bytea; + + left_block_size CONSTANT smallint := 16; + right_block_size CONSTANT smallint := 32; + + -- Block count N is DERIVED from the ciphertext length, not hardcoded to 8. + -- Wire format per term: + -- [ N PRP bytes ][ N*16B left blocks ][ 16B hash key ][ N*32B right blocks ] + -- octet_length = 17*N + 16 + 32*N = 49*N + 16 => N = (octet_length - 16) / 49 + -- This serves integer (N=8, 408B), timestamp (N=12, 604B), and numeric + -- (N=14, 702B) with one comparator. + n integer; + left_offset integer; -- ordinal offset of the first left block (1 + N PRP bytes) + right_offset integer; -- ordinal start of the right CT (= total left CT length = 17*N) + + indicator smallint := 0; + BEGIN + IF a IS NULL AND b IS NULL THEN + RETURN 0; + END IF; + + IF a IS NULL THEN + RETURN -1; + END IF; + + IF b IS NULL THEN + RETURN 1; + END IF; + + IF bit_length(a.bytes) != bit_length(b.bytes) THEN + RAISE EXCEPTION 'Ciphertexts are different lengths'; + END IF; + + -- Well-formedness: length must be exactly 49*N + 16 for some N >= 1. The + -- modulo alone is insufficient -- a 16-byte term passes (16 - 16) % 49 = 0 + -- and derives N = 0, which would fall through to the all-blocks-equal path + -- and return 0 instead of raising. The `<= 16` clause is load-bearing. + IF octet_length(a.bytes) <= 16 OR (octet_length(a.bytes) - 16) % 49 != 0 THEN + RAISE EXCEPTION 'Malformed ORE term: % bytes', octet_length(a.bytes); + END IF; + + n := (octet_length(a.bytes) - 16) / 49; + left_offset := 1 + n; -- left blocks begin right after the N PRP bytes + right_offset := 17 * n; -- right CT begins right after the 17*N-byte left CT + + FOR block IN 0..n-1 LOOP + -- Compare each PRP byte (the first N bytes) and its 16-byte left block. + IF + substr(a.bytes, 1 + block, 1) != substr(b.bytes, 1 + block, 1) + OR substr(a.bytes, left_offset + left_block_size * block, left_block_size) != substr(b.bytes, left_offset + left_block_size * block, left_block_size) + THEN + IF eq THEN + unequal_block := block; + END IF; + eq = false; + END IF; + END LOOP; + + IF eq THEN + RETURN 0::integer; + END IF; + + -- Hash key is the IV from the right CT of b. + hash_key := substr(b.bytes, right_offset + 1, 16); + + -- First right block is at right_offset + nonce_size (ordinally indexed). + target_block := substr(b.bytes, right_offset + 17 + (unequal_block * right_block_size), right_block_size); + + data_block := substr(a.bytes, left_offset + (left_block_size * unequal_block), left_block_size); + + encrypt_block := encrypt(data_block::bytea, hash_key::bytea, 'aes-ecb'); + + indicator := ( + get_bit( + encrypt_block, + 0 + ) + get_bit(target_block, get_byte(a.bytes, unequal_block))) % 2; + + IF indicator = 1 THEN + RETURN 1::integer; + ELSE + RETURN -1::integer; + END IF; + END; +$$ LANGUAGE plpgsql; + + +--! @brief Compare arrays of ORE block terms recursively +--! @internal +--! @param a eql_v3_internal.ore_block_256_term[] First array +--! @param b eql_v3_internal.ore_block_256_term[] Second array +--! @return integer -1/0/1, or NULL if either array is NULL +CREATE FUNCTION eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256_term[], b eql_v3_internal.ore_block_256_term[]) +RETURNS integer + IMMUTABLE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + cmp_result integer; + BEGIN + IF a IS NULL OR b IS NULL THEN + RETURN NULL; + END IF; + + IF cardinality(a) = 0 AND cardinality(b) = 0 THEN + RETURN 0; + END IF; + + IF (cardinality(a) = 0) AND cardinality(b) > 0 THEN + RETURN -1; + END IF; + + IF cardinality(a) > 0 AND (cardinality(b) = 0) THEN + RETURN 1; + END IF; + + cmp_result := eql_v3_internal.compare_ore_block_256_term(a[1], b[1]); + + IF cmp_result = 0 THEN + RETURN eql_v3_internal.compare_ore_block_256_terms(a[2:array_length(a,1)], b[2:array_length(b,1)]); + END IF; + + RETURN cmp_result; + END +$$ LANGUAGE plpgsql; + + +--! @brief Compare ORE block composite types +--! @internal +--! @param a eql_v3_internal.ore_block_256 First ORE block +--! @param b eql_v3_internal.ore_block_256 Second ORE block +--! @return integer -1/0/1 +CREATE FUNCTION eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) +RETURNS integer + IMMUTABLE + SET search_path = pg_catalog, extensions, public +AS $$ + BEGIN + RETURN eql_v3_internal.compare_ore_block_256_terms(a.terms, b.terms); + 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_ope_term(col)` engages structurally for the `_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[]; + +--! @file v3/sem/ore_cllw/types.sql +--! @brief CLLW ORE index term type for STE-vec range queries (eql_v3 SEM) +--! +--! Composite type for CLLW (Copyless Logarithmic Width) Order-Revealing +--! Encryption. The ciphertext is stored in the `oc` field of encrypted data +--! payloads (Standard-mode `ste_vec` elements). Used by the range operators +--! (`<`, `<=`, `>`, `>=`) when an sv element carries an `oc` term. +--! +--! The wire-format `oc` value is a hex string with a leading domain-tag byte +--! (`0x00` numeric, `0x01` string) followed by the CLLW ciphertext. The +--! decoded `bytes` field carries the full byte string including the tag — the +--! comparator is variable-length capable, so numeric and string values within +--! the same column order correctly: the domain tag separates the ranges +--! (numeric < string) and the within-domain comparison falls through to the +--! CLLW per-byte protocol. +--! +--! @note This is a transient type used only during query execution. +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE TYPE eql_v3_internal.ore_cllw AS ( + bytes bytea +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/timestamp/timestamp_types.sql +--! @brief Encrypted-domain types for timestamp. + +DO $$ +BEGIN + --! @brief Encrypted domain eql_v3.timestamp. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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; + + --! @brief Encrypted domain eql_v3.timestamp_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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; + + --! @brief Encrypted domain eql_v3.timestamp_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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; + + --! @brief Encrypted domain eql_v3.timestamp_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.timestamp_ord 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; + + --! @brief Encrypted domain eql_v3.timestamp_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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; +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/<T>/. +--! 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.<T>*) +--! @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.<T>*) +--! @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.<T>*) +--! @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. +--! +--! The six backing functions are inlinable single-statement SQL so the planner +--! can fold the eql_v3 comparison wrappers through to functional-index matching. + +--! @brief Equality backing function for ORE block types +--! @internal +--! +--! @param a eql_v3_internal.ore_block_256 Left operand +--! @param b eql_v3_internal.ore_block_256 Right operand +--! @return boolean True if the ORE blocks are equal +--! +--! @see eql_v3_internal.compare_ore_block_256_terms +CREATE FUNCTION eql_v3_internal.ore_block_256_eq(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) +RETURNS boolean + LANGUAGE sql + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = 0 +$$; + +--! @brief Not-equal backing function for ORE block types +--! @internal +--! +--! @param a eql_v3_internal.ore_block_256 Left operand +--! @param b eql_v3_internal.ore_block_256 Right operand +--! @return boolean True if the ORE blocks are not equal +--! +--! @see eql_v3_internal.compare_ore_block_256_terms +CREATE FUNCTION eql_v3_internal.ore_block_256_neq(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) +RETURNS boolean + LANGUAGE sql + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) <> 0 +$$; + +--! @brief Less-than backing function for ORE block types +--! @internal +--! +--! @param a eql_v3_internal.ore_block_256 Left operand +--! @param b eql_v3_internal.ore_block_256 Right operand +--! @return boolean True if the left operand is less than the right operand +--! +--! @see eql_v3_internal.compare_ore_block_256_terms +CREATE FUNCTION eql_v3_internal.ore_block_256_lt(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) +RETURNS boolean + LANGUAGE sql + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = -1 +$$; + +--! @brief Less-than-or-equal backing function for ORE block types +--! @internal +--! +--! @param a eql_v3_internal.ore_block_256 Left operand +--! @param b eql_v3_internal.ore_block_256 Right operand +--! @return boolean True if the left operand is less than or equal to the right operand +--! +--! @see eql_v3_internal.compare_ore_block_256_terms +CREATE FUNCTION eql_v3_internal.ore_block_256_lte(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) +RETURNS boolean + LANGUAGE sql + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) != 1 +$$; + +--! @brief Greater-than backing function for ORE block types +--! @internal +--! +--! @param a eql_v3_internal.ore_block_256 Left operand +--! @param b eql_v3_internal.ore_block_256 Right operand +--! @return boolean True if the left operand is greater than the right operand +--! +--! @see eql_v3_internal.compare_ore_block_256_terms +CREATE FUNCTION eql_v3_internal.ore_block_256_gt(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) +RETURNS boolean + LANGUAGE sql + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = 1 +$$; + +--! @brief Greater-than-or-equal backing function for ORE block types +--! @internal +--! +--! @param a eql_v3_internal.ore_block_256 Left operand +--! @param b eql_v3_internal.ore_block_256 Right operand +--! @return boolean True if the left operand is greater than or equal to the right operand +--! +--! @see eql_v3_internal.compare_ore_block_256_terms +CREATE FUNCTION eql_v3_internal.ore_block_256_gte(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) +RETURNS boolean + LANGUAGE sql + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) != -1 +$$; + + +--! @brief = operator for ORE block types +--! +--! COMMUTATOR is the operator itself: equality is symmetric. Required for the +--! MERGES flag — without it the planner raises "could not find commutator" the +--! first time an ore_block equality is used as a join qual (e.g. via the inlined +--! eql_v3_internal.<T>_ord_ore equality wrappers). +CREATE OPERATOR public.= ( + FUNCTION=eql_v3_internal.ore_block_256_eq, + LEFTARG=eql_v3_internal.ore_block_256, + RIGHTARG=eql_v3_internal.ore_block_256, + COMMUTATOR = OPERATOR(public.=), + NEGATOR = OPERATOR(public.<>), + RESTRICT = eqsel, + JOIN = eqjoinsel, + HASHES, + MERGES +); + +--! @brief <> operator for ORE block types +CREATE OPERATOR public.<> ( + FUNCTION=eql_v3_internal.ore_block_256_neq, + LEFTARG=eql_v3_internal.ore_block_256, + RIGHTARG=eql_v3_internal.ore_block_256, + COMMUTATOR = OPERATOR(public.<>), + NEGATOR = OPERATOR(public.=), + RESTRICT = neqsel, + JOIN = neqjoinsel, + MERGES +); + +--! @brief > operator for ORE block types +CREATE OPERATOR public.> ( + FUNCTION=eql_v3_internal.ore_block_256_gt, + LEFTARG=eql_v3_internal.ore_block_256, + RIGHTARG=eql_v3_internal.ore_block_256, + COMMUTATOR = OPERATOR(public.<), + NEGATOR = OPERATOR(public.<=), + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel +); + +--! @brief < operator for ORE block types +CREATE OPERATOR public.< ( + FUNCTION=eql_v3_internal.ore_block_256_lt, + LEFTARG=eql_v3_internal.ore_block_256, + RIGHTARG=eql_v3_internal.ore_block_256, + COMMUTATOR = OPERATOR(public.>), + NEGATOR = OPERATOR(public.>=), + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel +); + +--! @brief <= operator for ORE block types +CREATE OPERATOR public.<= ( + FUNCTION=eql_v3_internal.ore_block_256_lte, + LEFTARG=eql_v3_internal.ore_block_256, + RIGHTARG=eql_v3_internal.ore_block_256, + COMMUTATOR = OPERATOR(public.>=), + NEGATOR = OPERATOR(public.>), + RESTRICT = scalarlesel, + JOIN = scalarlejoinsel +); + +--! @brief >= operator for ORE block types +CREATE OPERATOR public.>= ( + FUNCTION=eql_v3_internal.ore_block_256_gte, + LEFTARG=eql_v3_internal.ore_block_256, + RIGHTARG=eql_v3_internal.ore_block_256, + COMMUTATOR = OPERATOR(public.<=), + NEGATOR = 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_ope_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)'; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/text/text_types.sql +--! @brief Encrypted-domain types for text. + +DO $$ +BEGIN + --! @brief Encrypted domain eql_v3.text. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.text AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + --! @brief Encrypted domain eql_v3.text_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.text_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; + + --! @brief Encrypted domain eql_v3.text_match. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_match' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.text_match AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'bf' + AND VALUE->>'v' = '3' + ); + END IF; + + --! @brief Encrypted domain eql_v3.text_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.text_ord_ore 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->>'v' = '3' + ); + END IF; + + --! @brief Encrypted domain eql_v3.text_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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 ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + --! @brief Encrypted domain eql_v3.text_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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; + + --! @brief Encrypted domain eql_v3.text_search. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_search' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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 ? 'ob' + AND VALUE ? 'bf' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; +END +$$; + +--! @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 +$$; + +--! @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 v3/scalars/smallint/smallint_types.sql +--! @brief Encrypted-domain types for smallint. + +DO $$ +BEGIN + --! @brief Encrypted domain eql_v3.smallint. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.smallint AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + --! @brief Encrypted domain eql_v3.smallint_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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; + + --! @brief Encrypted domain eql_v3.smallint_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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 jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + --! @brief Encrypted domain eql_v3.smallint_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.smallint_ord 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; + + --! @brief Encrypted domain eql_v3.smallint_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.smallint_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; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/real/real_types.sql +--! @brief Encrypted-domain types for real. + +DO $$ +BEGIN + --! @brief Encrypted domain eql_v3.real. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.real AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + --! @brief Encrypted domain eql_v3.real_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.real_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; + + --! @brief Encrypted domain eql_v3.real_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.real_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; + + --! @brief Encrypted domain eql_v3.real_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.real_ord 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; + + --! @brief Encrypted domain eql_v3.real_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.real_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; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/numeric/numeric_types.sql +--! @brief Encrypted-domain types for numeric. + +DO $$ +BEGIN + --! @brief Encrypted domain eql_v3.numeric. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.numeric AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + --! @brief Encrypted domain eql_v3.numeric_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.numeric_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; + + --! @brief Encrypted domain eql_v3.numeric_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.numeric_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; + + --! @brief Encrypted domain eql_v3.numeric_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.numeric_ord 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; + + --! @brief Encrypted domain eql_v3.numeric_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.numeric_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; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/integer/integer_types.sql +--! @brief Encrypted-domain types for integer. + +DO $$ +BEGIN + --! @brief Encrypted domain eql_v3.integer. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.integer AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + --! @brief Encrypted domain eql_v3.integer_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.integer_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; + + --! @brief Encrypted domain eql_v3.integer_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.integer_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; + + --! @brief Encrypted domain eql_v3.integer_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.integer_ord 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; + + --! @brief Encrypted domain eql_v3.integer_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.integer_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; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/double/double_types.sql +--! @brief Encrypted-domain types for double. + +DO $$ +BEGIN + --! @brief Encrypted domain eql_v3.double. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.double AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + --! @brief Encrypted domain eql_v3.double_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.double_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; + + --! @brief Encrypted domain eql_v3.double_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.double_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; + + --! @brief Encrypted domain eql_v3.double_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.double_ord 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; + + --! @brief Encrypted domain eql_v3.double_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.double_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; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/date/date_types.sql +--! @brief Encrypted-domain types for date. + +DO $$ +BEGIN + --! @brief Encrypted domain eql_v3.date. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.date AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + --! @brief Encrypted domain eql_v3.date_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.date_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; + + --! @brief Encrypted domain eql_v3.date_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.date_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; + + --! @brief Encrypted domain eql_v3.date_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.date_ord 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; + + --! @brief Encrypted domain eql_v3.date_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.date_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; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/bigint/bigint_types.sql +--! @brief Encrypted-domain types for bigint. + +DO $$ +BEGIN + --! @brief Encrypted domain eql_v3.bigint. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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 Encrypted domain eql_v3.bigint_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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; + + --! @brief Encrypted domain eql_v3.bigint_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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; + + --! @brief Encrypted domain eql_v3.bigint_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.bigint_ord 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; + + --! @brief Encrypted domain eql_v3.bigint_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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; +END +$$; + +--! @file v3/sem/ore_cllw/functions.sql +--! @brief CLLW ORE index-term extraction and comparison (eql_v3 SEM). + +--! @brief Extract CLLW ORE index term from raw jsonb +--! +--! Returns the CLLW ORE ciphertext from the `oc` field of a single sv element +--! supplied as raw jsonb. Inlinable single-statement SQL — the planner folds +--! the body into the calling query. +--! +--! **Missing-`oc` semantics**: returns SQL-level NULL (not a composite with +--! NULL bytes) when `oc` is absent, so btree's NULL handling filters those +--! rows from range queries. +--! +--! @param val jsonb An object carrying an `oc` field +--! @return eql_v3_internal.ore_cllw Composite carrying the CLLW ciphertext, or NULL +--! when the `oc` field is absent. +--! @see eql_v3_internal.has_ore_cllw +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.ore_cllw(val jsonb) + RETURNS eql_v3_internal.ore_cllw + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT CASE WHEN val ->> 'oc' IS NULL THEN NULL + ELSE ROW(decode(val ->> 'oc', 'hex'))::eql_v3_internal.ore_cllw + END +$$; + +COMMENT ON FUNCTION eql_v3_internal.ore_cllw(jsonb) IS + 'eql-inline-critical: raw-jsonb CLLW extractor; must stay inlinable (unpinned search_path)'; + +--! @brief Check if a raw jsonb value contains a CLLW ORE index term +--! @param val jsonb An object that may carry an `oc` field +--! @return boolean True if `oc` field is present and non-null +CREATE FUNCTION eql_v3_internal.has_ore_cllw(val jsonb) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT val ->> 'oc' IS NOT NULL +$$; + +COMMENT ON FUNCTION eql_v3_internal.has_ore_cllw(jsonb) IS + 'eql-inline-critical: raw-jsonb CLLW presence helper; must stay inlinable (unpinned search_path)'; + +--! @brief CLLW per-byte comparison helper +--! @internal +--! +--! Byte-by-byte comparison implementing the CLLW order-revealing protocol. +--! Identify the index of the first differing byte; if `(y_byte + 1) == x_byte` +--! (mod 256) there, then x > y; otherwise x < y. Equal inputs return 0. Inputs +--! MUST be the same length (the caller guarantees this). Stays `LANGUAGE +--! plpgsql` — the per-byte loop can't be a single inlinable SQL expression. +--! +--! @param a bytea First CLLW ciphertext slice +--! @param b bytea Second CLLW ciphertext slice +--! @return integer -1, 0, or 1 +--! @throws Exception if inputs are different lengths +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.compare_ore_cllw_term_bytes(a bytea, b bytea) +RETURNS int + SET search_path = pg_catalog, extensions, public +AS $$ +DECLARE + len_a INT; + len_b INT; + i INT; + first_diff INT := 0; +BEGIN + + len_a := LENGTH(a); + len_b := LENGTH(b); + + IF len_a != len_b THEN + RAISE EXCEPTION 'ore_cllw index terms are not the same length'; + END IF; + + FOR i IN 1..len_a LOOP + IF first_diff = 0 AND get_byte(a, i - 1) != get_byte(b, i - 1) THEN + first_diff := i; + END IF; + END LOOP; + + IF first_diff = 0 THEN + RETURN 0; + END IF; + + IF ((get_byte(b, first_diff - 1) + 1) & 255) = get_byte(a, first_diff - 1) THEN + RETURN 1; + ELSE + RETURN -1; + END IF; +END; +$$ LANGUAGE plpgsql; + +--! @brief Variable-length CLLW ORE term comparison +--! @internal +--! +--! Three-way comparison of two CLLW ORE ciphertext terms of potentially +--! different lengths. Compares the shared prefix via the CLLW per-byte +--! protocol; on equal prefixes, the shorter input sorts first. The leading +--! domain-tag byte makes numeric (`0x00`) sort before string (`0x01`). Stays +--! `LANGUAGE plpgsql` because it dispatches to `compare_ore_cllw_term_bytes`. +--! +--! btree filters NULL composites at the row level, so this should never see a +--! NULL composite under normal operation; the IS-NULL guard returns NULL +--! defensively. A non-NULL composite with NULL `bytes` is a contract violation +--! — the extractor returns SQL NULL (not ROW(NULL)) on missing `oc`, so raise +--! loudly rather than silently misorder. +--! +--! @param a eql_v3_internal.ore_cllw First term +--! @param b eql_v3_internal.ore_cllw Second term +--! @return integer -1, 0, or 1; NULL if either composite is NULL +--! @throws Exception if either composite has a NULL `bytes` field +--! @see eql_v3_internal.compare_ore_cllw_term_bytes +CREATE FUNCTION eql_v3_internal.compare_ore_cllw_term(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) +RETURNS int + SET search_path = pg_catalog, extensions, public +AS $$ +DECLARE + len_a INT; + len_b INT; + common_len INT; + cmp_result INT; +BEGIN + -- The `::text` cast is load-bearing, not a stylistic choice. For the + -- single-field `ore_cllw` composite, `ROW(NULL)::ore_cllw IS NULL` is TRUE + -- but `(ROW(NULL)::ore_cllw)::text IS NULL` is FALSE. Casting to text first + -- means a NULL-component composite falls THROUGH to the RAISE below (the + -- extractor-invariant violation) instead of silently returning NULL and + -- masking it. A plain `a IS NULL` would reintroduce that masking bug. + IF a::text IS NULL OR b::text IS NULL THEN + RETURN NULL; + END IF; + + IF a.bytes IS NULL OR b.bytes IS NULL THEN + RAISE EXCEPTION 'eql_v3_internal.compare_ore_cllw_term: composite has NULL bytes field — extractor invariant violated. Check that the index expression uses eql_v3_internal.ore_cllw(...) and not a hand-crafted ROW(NULL).'; + END IF; + + len_a := LENGTH(a.bytes); + len_b := LENGTH(b.bytes); + + IF len_a = 0 AND len_b = 0 THEN + RETURN 0; + ELSIF len_a = 0 THEN + RETURN -1; + ELSIF len_b = 0 THEN + RETURN 1; + END IF; + + IF len_a < len_b THEN + common_len := len_a; + ELSE + common_len := len_b; + END IF; + + cmp_result := eql_v3_internal.compare_ore_cllw_term_bytes( + SUBSTRING(a.bytes FROM 1 FOR common_len), + SUBSTRING(b.bytes FROM 1 FOR common_len) + ); + + IF cmp_result = -1 THEN + RETURN -1; + ELSIF cmp_result = 1 THEN + RETURN 1; + END IF; + + IF len_a < len_b THEN + RETURN -1; + ELSIF len_a > len_b THEN + RETURN 1; + ELSE + RETURN 0; + END IF; +END; +$$ LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ore_functions.sql +--! @brief Functions for eql_v3.timestamp_ord_ore. + +--! @brief Index extractor for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a 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) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.timestamp_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.timestamp_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.timestamp_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.timestamp_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.timestamp_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.timestamp_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param selector text +--! @return eql_v3.timestamp_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_ord_ore, selector text) +RETURNS eql_v3.timestamp_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param selector integer +--! @return eql_v3.timestamp_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_ord_ore, selector integer) +RETURNS eql_v3.timestamp_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.timestamp_ord_ore +--! @return eql_v3.timestamp_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.timestamp_ord_ore) +RETURNS eql_v3.timestamp_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.timestamp_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.timestamp_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.timestamp_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.timestamp_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.timestamp_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.timestamp_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.timestamp_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.timestamp_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.timestamp_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.timestamp_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b eql_v3.timestamp_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.timestamp_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ope_functions.sql +--! @brief Functions for eql_v3.timestamp_ord_ope. + +--! @brief Index extractor for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a 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 eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.timestamp_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.timestamp_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.timestamp_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.timestamp_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.timestamp_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.timestamp_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.timestamp_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.timestamp_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.timestamp_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.timestamp_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.timestamp_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.timestamp_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.timestamp_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.timestamp_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param selector text +--! @return eql_v3.timestamp_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_ord_ope, selector text) +RETURNS eql_v3.timestamp_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param selector integer +--! @return eql_v3.timestamp_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_ord_ope, selector integer) +RETURNS eql_v3.timestamp_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.timestamp_ord_ope +--! @return eql_v3.timestamp_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.timestamp_ord_ope) +RETURNS eql_v3.timestamp_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.timestamp_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.timestamp_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.timestamp_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.timestamp_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.timestamp_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.timestamp_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.timestamp_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.timestamp_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.timestamp_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.timestamp_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b eql_v3.timestamp_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.timestamp_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_functions.sql +--! @brief Functions for eql_v3.timestamp_ord. + +--! @brief Index extractor for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.timestamp_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_ord, b 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 eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.timestamp_ord) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_ord, b 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 eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.timestamp_ord) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.timestamp_ord, b 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 eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a 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::eql_v3.timestamp_ord) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.timestamp_ord, b 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 eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a 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::eql_v3.timestamp_ord) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.timestamp_ord, b 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 eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a 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::eql_v3.timestamp_ord) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.timestamp_ord, b 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 eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a 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::eql_v3.timestamp_ord) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param selector text +--! @return eql_v3.timestamp_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_ord, selector text) +RETURNS eql_v3.timestamp_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param selector integer +--! @return eql_v3.timestamp_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_ord, selector integer) +RETURNS eql_v3.timestamp_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a jsonb +--! @param selector eql_v3.timestamp_ord +--! @return eql_v3.timestamp_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.timestamp_ord) +RETURNS eql_v3.timestamp_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a jsonb +--! @param selector eql_v3.timestamp_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.timestamp_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.timestamp_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.timestamp_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.timestamp_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.timestamp_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.timestamp_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.timestamp_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.timestamp_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.timestamp_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b eql_v3.timestamp_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.timestamp_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_search_functions.sql +--! @brief Functions for eql_v3.text_search. + +--! @brief Index extractor for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a 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) $$; + +--! @brief Index extractor for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.text_search) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Index extractor for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @return eql_v3_internal.bloom_filter +CREATE FUNCTION eql_v3.match_term(a 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.text_search. +--! @param a eql_v3.text_search +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.text_search, b 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.text_search. +--! @param a eql_v3.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.text_search) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a jsonb +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_search) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.text_search, b 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.text_search. +--! @param a eql_v3.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.text_search) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a jsonb +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_search) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.text_search, b eql_v3.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.text_search. +--! @param a eql_v3.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a 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::eql_v3.text_search) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a jsonb +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_search) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.text_search, b eql_v3.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.text_search. +--! @param a eql_v3.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a 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::eql_v3.text_search) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a jsonb +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_search) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.text_search, b eql_v3.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.text_search. +--! @param a eql_v3.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a 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::eql_v3.text_search) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a jsonb +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_search) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.text_search, b eql_v3.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.text_search. +--! @param a eql_v3.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a 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::eql_v3.text_search) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a jsonb +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_search) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.text_search, b 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.text_search. +--! @param a eql_v3.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(a 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::eql_v3.text_search) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a jsonb +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::eql_v3.text_search) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.text_search, b 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.text_search. +--! @param a eql_v3.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a 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::eql_v3.text_search) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a jsonb +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::eql_v3.text_search) <@ eql_v3.match_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param selector text +--! @return eql_v3.text_search +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_search, selector text) +RETURNS eql_v3.text_search IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param selector integer +--! @return eql_v3.text_search +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_search, selector integer) +RETURNS eql_v3.text_search IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a jsonb +--! @param selector eql_v3.text_search +--! @return eql_v3.text_search +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text_search) +RETURNS eql_v3.text_search IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_search, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_search, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a jsonb +--! @param selector eql_v3.text_search +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text_search) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text_search, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text_search, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text_search, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text_search, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text_search, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text_search, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text_search, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_search, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_search, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_search, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text_search, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b eql_v3.text_search +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_search, b eql_v3.text_search) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_search, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a jsonb +--! @param b eql_v3.text_search +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text_search) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ore_functions.sql +--! @brief Functions for eql_v3.text_ord_ore. + +--! @brief Index extractor for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a 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) $$; + +--! @brief Index extractor for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a 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) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.text_ord_ore, b 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.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.text_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord_ore) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.text_ord_ore, b 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.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.text_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord_ore) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.text_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.text_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.text_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.text_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param selector text +--! @return eql_v3.text_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_ord_ore, selector text) +RETURNS eql_v3.text_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param selector integer +--! @return eql_v3.text_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_ord_ore, selector integer) +RETURNS eql_v3.text_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.text_ord_ore +--! @return eql_v3.text_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text_ord_ore) +RETURNS eql_v3.text_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.text_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b eql_v3.text_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param b eql_v3.text_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ope_functions.sql +--! @brief Functions for eql_v3.text_ord_ope. + +--! @brief Index extractor for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a 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 Index extractor for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a 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 Operator wrapper for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.text_ord_ope, b 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.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.text_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a jsonb +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord_ope) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.text_ord_ope, b 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.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.text_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a jsonb +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord_ope) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.text_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a jsonb +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.text_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.text_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a jsonb +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.text_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.text_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a jsonb +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.text_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.text_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a jsonb +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.text_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a jsonb +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.text_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a jsonb +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.text_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param selector text +--! @return eql_v3.text_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_ord_ope, selector text) +RETURNS eql_v3.text_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param selector integer +--! @return eql_v3.text_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_ord_ope, selector integer) +RETURNS eql_v3.text_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.text_ord_ope +--! @return eql_v3.text_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text_ord_ope) +RETURNS eql_v3.text_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.text_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b eql_v3.text_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a jsonb +--! @param b eql_v3.text_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_functions.sql +--! @brief Functions for eql_v3.text_ord. + +--! @brief Index extractor for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a 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) $$; + +--! @brief Index extractor for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.text_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.text_ord, b 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.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.text_ord) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a jsonb +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.text_ord, b 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.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.text_ord) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a jsonb +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord, b 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.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.text_ord) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a jsonb +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord, b 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.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.text_ord) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a jsonb +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord, b 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.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.text_ord) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a jsonb +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord, b 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.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.text_ord) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a jsonb +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_ord, b eql_v3.text_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a jsonb +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.text_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_ord, b eql_v3.text_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a jsonb +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.text_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param selector text +--! @return eql_v3.text_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_ord, selector text) +RETURNS eql_v3.text_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param selector integer +--! @return eql_v3.text_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_ord, selector integer) +RETURNS eql_v3.text_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a jsonb +--! @param selector eql_v3.text_ord +--! @return eql_v3.text_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text_ord) +RETURNS eql_v3.text_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a jsonb +--! @param selector eql_v3.text_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b eql_v3.text_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_ord, b eql_v3.text_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a jsonb +--! @param b eql_v3.text_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ore_functions.sql +--! @brief Functions for eql_v3.smallint_ord_ore. + +--! @brief Index extractor for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.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.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.smallint_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.smallint_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.smallint_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.smallint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.smallint_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.smallint_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.smallint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.smallint_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.smallint_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.smallint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.smallint_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.smallint_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.smallint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.smallint_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_ord_ore, b eql_v3.smallint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.smallint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_ord_ore, b eql_v3.smallint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.smallint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param selector text +--! @return eql_v3.smallint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_ord_ore, selector text) +RETURNS eql_v3.smallint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param selector integer +--! @return eql_v3.smallint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_ord_ore, selector integer) +RETURNS eql_v3.smallint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.smallint_ord_ore +--! @return eql_v3.smallint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.smallint_ord_ore) +RETURNS eql_v3.smallint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.smallint_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.smallint_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.smallint_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.smallint_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.smallint_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.smallint_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.smallint_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.smallint_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.smallint_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.smallint_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b eql_v3.smallint_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_ord_ore, b eql_v3.smallint_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.smallint_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ope_functions.sql +--! @brief Functions for eql_v3.smallint_ord_ope. + +--! @brief Index extractor for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a 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 eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.smallint_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.smallint_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.smallint_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.smallint_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.smallint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.smallint_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.smallint_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.smallint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.smallint_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.smallint_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.smallint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.smallint_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.smallint_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.smallint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.smallint_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.smallint_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.smallint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.smallint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param selector text +--! @return eql_v3.smallint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_ord_ope, selector text) +RETURNS eql_v3.smallint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param selector integer +--! @return eql_v3.smallint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_ord_ope, selector integer) +RETURNS eql_v3.smallint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.smallint_ord_ope +--! @return eql_v3.smallint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.smallint_ord_ope) +RETURNS eql_v3.smallint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.smallint_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.smallint_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.smallint_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.smallint_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.smallint_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.smallint_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.smallint_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.smallint_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.smallint_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.smallint_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b eql_v3.smallint_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.smallint_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_functions.sql +--! @brief Functions for eql_v3.smallint_ord. + +--! @brief Index extractor for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.smallint_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_ord, b 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.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.smallint_ord) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord. +--! @param a jsonb +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_ord, b 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.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.smallint_ord) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord. +--! @param a jsonb +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.smallint_ord, b 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.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.smallint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.smallint_ord) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord. +--! @param a jsonb +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.smallint_ord, b 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.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.smallint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.smallint_ord) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord. +--! @param a jsonb +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.smallint_ord, b 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.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.smallint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.smallint_ord) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord. +--! @param a jsonb +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.smallint_ord, b 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.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.smallint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.smallint_ord) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord. +--! @param a jsonb +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_ord, b eql_v3.smallint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a jsonb +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.smallint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_ord, b eql_v3.smallint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a jsonb +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.smallint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param selector text +--! @return eql_v3.smallint_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_ord, selector text) +RETURNS eql_v3.smallint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param selector integer +--! @return eql_v3.smallint_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_ord, selector integer) +RETURNS eql_v3.smallint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a jsonb +--! @param selector eql_v3.smallint_ord +--! @return eql_v3.smallint_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.smallint_ord) +RETURNS eql_v3.smallint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a jsonb +--! @param selector eql_v3.smallint_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.smallint_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.smallint_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.smallint_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.smallint_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.smallint_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.smallint_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.smallint_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.smallint_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.smallint_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b eql_v3.smallint_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_ord, b eql_v3.smallint_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a jsonb +--! @param b eql_v3.smallint_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.smallint_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ore_functions.sql +--! @brief Functions for eql_v3.real_ord_ore. + +--! @brief Index extractor for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a 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 eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.real_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a jsonb +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.real_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a jsonb +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.real_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a jsonb +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.real_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a jsonb +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.real_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a jsonb +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.real_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a jsonb +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a jsonb +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.real_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a jsonb +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.real_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param selector text +--! @return eql_v3.real_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_ord_ore, selector text) +RETURNS eql_v3.real_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param selector integer +--! @return eql_v3.real_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_ord_ore, selector integer) +RETURNS eql_v3.real_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.real_ord_ore +--! @return eql_v3.real_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.real_ord_ore) +RETURNS eql_v3.real_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.real_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.real_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.real_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.real_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.real_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.real_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.real_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.real_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.real_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.real_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b eql_v3.real_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a jsonb +--! @param b eql_v3.real_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.real_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ope_functions.sql +--! @brief Functions for eql_v3.real_ord_ope. + +--! @brief Index extractor for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.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.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.real_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a jsonb +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.real_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.real_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a jsonb +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.real_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.real_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a jsonb +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.real_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.real_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a jsonb +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.real_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.real_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a jsonb +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.real_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.real_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a jsonb +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.real_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a jsonb +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.real_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a jsonb +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.real_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param selector text +--! @return eql_v3.real_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_ord_ope, selector text) +RETURNS eql_v3.real_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param selector integer +--! @return eql_v3.real_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_ord_ope, selector integer) +RETURNS eql_v3.real_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.real_ord_ope +--! @return eql_v3.real_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.real_ord_ope) +RETURNS eql_v3.real_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.real_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.real_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.real_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.real_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.real_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.real_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.real_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.real_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.real_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.real_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b eql_v3.real_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a jsonb +--! @param b eql_v3.real_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.real_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_functions.sql +--! @brief Functions for eql_v3.real_ord. + +--! @brief Index extractor for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.real_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.real_ord, b 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.real_ord. +--! @param a eql_v3.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.real_ord) $$; + +--! @brief Operator wrapper for eql_v3.real_ord. +--! @param a jsonb +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.real_ord, b 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.real_ord. +--! @param a eql_v3.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.real_ord) $$; + +--! @brief Operator wrapper for eql_v3.real_ord. +--! @param a jsonb +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.real_ord, b 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.real_ord. +--! @param a eql_v3.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a 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::eql_v3.real_ord) $$; + +--! @brief Operator wrapper for eql_v3.real_ord. +--! @param a jsonb +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.real_ord, b 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.real_ord. +--! @param a eql_v3.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a 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::eql_v3.real_ord) $$; + +--! @brief Operator wrapper for eql_v3.real_ord. +--! @param a jsonb +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.real_ord, b 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.real_ord. +--! @param a eql_v3.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a 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::eql_v3.real_ord) $$; + +--! @brief Operator wrapper for eql_v3.real_ord. +--! @param a jsonb +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.real_ord, b 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.real_ord. +--! @param a eql_v3.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a 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::eql_v3.real_ord) $$; + +--! @brief Operator wrapper for eql_v3.real_ord. +--! @param a jsonb +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_ord, b eql_v3.real_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a jsonb +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.real_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_ord, b eql_v3.real_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a jsonb +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.real_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param selector text +--! @return eql_v3.real_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_ord, selector text) +RETURNS eql_v3.real_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param selector integer +--! @return eql_v3.real_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_ord, selector integer) +RETURNS eql_v3.real_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a jsonb +--! @param selector eql_v3.real_ord +--! @return eql_v3.real_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.real_ord) +RETURNS eql_v3.real_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a jsonb +--! @param selector eql_v3.real_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.real_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.real_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.real_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.real_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.real_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.real_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.real_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.real_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.real_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b eql_v3.real_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_ord, b eql_v3.real_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a jsonb +--! @param b eql_v3.real_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.real_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ore_functions.sql +--! @brief Functions for eql_v3.numeric_ord_ore. + +--! @brief Index extractor for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a 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 eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.numeric_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.numeric_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.numeric_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a 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::eql_v3.numeric_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.numeric_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a 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::eql_v3.numeric_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.numeric_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a 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::eql_v3.numeric_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.numeric_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a 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::eql_v3.numeric_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.numeric_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.numeric_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param selector text +--! @return eql_v3.numeric_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_ord_ore, selector text) +RETURNS eql_v3.numeric_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param selector integer +--! @return eql_v3.numeric_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_ord_ore, selector integer) +RETURNS eql_v3.numeric_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.numeric_ord_ore +--! @return eql_v3.numeric_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.numeric_ord_ore) +RETURNS eql_v3.numeric_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.numeric_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.numeric_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.numeric_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.numeric_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.numeric_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.numeric_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.numeric_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.numeric_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.numeric_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.numeric_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b eql_v3.numeric_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.numeric_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ope_functions.sql +--! @brief Functions for eql_v3.numeric_ord_ope. + +--! @brief Index extractor for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a 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 eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.numeric_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.numeric_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.numeric_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.numeric_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.numeric_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.numeric_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.numeric_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.numeric_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.numeric_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.numeric_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.numeric_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.numeric_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.numeric_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.numeric_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.numeric_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.numeric_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.numeric_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.numeric_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param selector text +--! @return eql_v3.numeric_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_ord_ope, selector text) +RETURNS eql_v3.numeric_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param selector integer +--! @return eql_v3.numeric_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_ord_ope, selector integer) +RETURNS eql_v3.numeric_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.numeric_ord_ope +--! @return eql_v3.numeric_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.numeric_ord_ope) +RETURNS eql_v3.numeric_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.numeric_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.numeric_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.numeric_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.numeric_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.numeric_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.numeric_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.numeric_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.numeric_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.numeric_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.numeric_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b eql_v3.numeric_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.numeric_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_functions.sql +--! @brief Functions for eql_v3.numeric_ord. + +--! @brief Index extractor for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.numeric_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord, b 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.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.numeric_ord) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a jsonb +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord, b 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.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.numeric_ord) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a jsonb +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.numeric_ord, b 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.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a 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::eql_v3.numeric_ord) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a jsonb +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.numeric_ord, b 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.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a 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::eql_v3.numeric_ord) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a jsonb +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.numeric_ord, b 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.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a 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::eql_v3.numeric_ord) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a jsonb +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.numeric_ord, b 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.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a 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::eql_v3.numeric_ord) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a jsonb +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_ord, b eql_v3.numeric_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a jsonb +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.numeric_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_ord, b eql_v3.numeric_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a jsonb +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.numeric_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param selector text +--! @return eql_v3.numeric_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_ord, selector text) +RETURNS eql_v3.numeric_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param selector integer +--! @return eql_v3.numeric_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_ord, selector integer) +RETURNS eql_v3.numeric_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a jsonb +--! @param selector eql_v3.numeric_ord +--! @return eql_v3.numeric_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.numeric_ord) +RETURNS eql_v3.numeric_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a jsonb +--! @param selector eql_v3.numeric_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.numeric_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.numeric_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.numeric_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.numeric_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.numeric_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.numeric_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.numeric_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.numeric_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.numeric_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b eql_v3.numeric_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_ord, b eql_v3.numeric_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a jsonb +--! @param b eql_v3.numeric_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.numeric_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ore_functions.sql +--! @brief Functions for eql_v3.integer_ord_ore. + +--! @brief Index extractor for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a 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 eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.integer_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.integer_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.integer_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.integer_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.integer_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.integer_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.integer_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.integer_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param selector text +--! @return eql_v3.integer_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_ord_ore, selector text) +RETURNS eql_v3.integer_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param selector integer +--! @return eql_v3.integer_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_ord_ore, selector integer) +RETURNS eql_v3.integer_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.integer_ord_ore +--! @return eql_v3.integer_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.integer_ord_ore) +RETURNS eql_v3.integer_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.integer_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.integer_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.integer_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.integer_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.integer_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.integer_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.integer_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.integer_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.integer_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.integer_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b eql_v3.integer_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.integer_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ope_functions.sql +--! @brief Functions for eql_v3.integer_ord_ope. + +--! @brief Index extractor for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a 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 eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.integer_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.integer_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.integer_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.integer_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.integer_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.integer_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.integer_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.integer_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.integer_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.integer_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.integer_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.integer_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.integer_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.integer_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.integer_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.integer_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.integer_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.integer_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.integer_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.integer_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param selector text +--! @return eql_v3.integer_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_ord_ope, selector text) +RETURNS eql_v3.integer_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param selector integer +--! @return eql_v3.integer_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_ord_ope, selector integer) +RETURNS eql_v3.integer_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.integer_ord_ope +--! @return eql_v3.integer_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.integer_ord_ope) +RETURNS eql_v3.integer_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.integer_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.integer_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.integer_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.integer_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.integer_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.integer_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.integer_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.integer_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.integer_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.integer_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b eql_v3.integer_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.integer_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_functions.sql +--! @brief Functions for eql_v3.integer_ord. + +--! @brief Index extractor for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.integer_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.integer_ord, b 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.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.integer_ord) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord. +--! @param a jsonb +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.integer_ord, b 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.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.integer_ord) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord. +--! @param a jsonb +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.integer_ord, b 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.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a 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::eql_v3.integer_ord) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord. +--! @param a jsonb +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.integer_ord, b 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.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a 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::eql_v3.integer_ord) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord. +--! @param a jsonb +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.integer_ord, b 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.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a 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::eql_v3.integer_ord) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord. +--! @param a jsonb +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.integer_ord, b 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.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a 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::eql_v3.integer_ord) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord. +--! @param a jsonb +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_ord, b eql_v3.integer_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a jsonb +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.integer_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_ord, b eql_v3.integer_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a jsonb +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.integer_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param selector text +--! @return eql_v3.integer_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_ord, selector text) +RETURNS eql_v3.integer_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param selector integer +--! @return eql_v3.integer_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_ord, selector integer) +RETURNS eql_v3.integer_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a jsonb +--! @param selector eql_v3.integer_ord +--! @return eql_v3.integer_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.integer_ord) +RETURNS eql_v3.integer_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a jsonb +--! @param selector eql_v3.integer_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.integer_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.integer_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.integer_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.integer_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.integer_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.integer_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.integer_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.integer_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.integer_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b eql_v3.integer_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_ord, b eql_v3.integer_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a jsonb +--! @param b eql_v3.integer_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.integer_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ore_functions.sql +--! @brief Functions for eql_v3.double_ord_ore. + +--! @brief Index extractor for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a 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 eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.double_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a jsonb +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.double_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a jsonb +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.double_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a jsonb +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.double_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a jsonb +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.double_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a jsonb +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.double_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a jsonb +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a jsonb +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.double_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a jsonb +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.double_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param selector text +--! @return eql_v3.double_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_ord_ore, selector text) +RETURNS eql_v3.double_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param selector integer +--! @return eql_v3.double_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_ord_ore, selector integer) +RETURNS eql_v3.double_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.double_ord_ore +--! @return eql_v3.double_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.double_ord_ore) +RETURNS eql_v3.double_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.double_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.double_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.double_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.double_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.double_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.double_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.double_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.double_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.double_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.double_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b eql_v3.double_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a jsonb +--! @param b eql_v3.double_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.double_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ope_functions.sql +--! @brief Functions for eql_v3.double_ord_ope. + +--! @brief Index extractor for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.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.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.double_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.double_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a jsonb +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.double_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.double_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.double_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a jsonb +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.double_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.double_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.double_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a jsonb +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.double_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.double_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.double_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a jsonb +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.double_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.double_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.double_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a jsonb +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.double_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.double_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.double_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a jsonb +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.double_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a jsonb +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.double_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a jsonb +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.double_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param selector text +--! @return eql_v3.double_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_ord_ope, selector text) +RETURNS eql_v3.double_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param selector integer +--! @return eql_v3.double_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_ord_ope, selector integer) +RETURNS eql_v3.double_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.double_ord_ope +--! @return eql_v3.double_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.double_ord_ope) +RETURNS eql_v3.double_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.double_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.double_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.double_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.double_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.double_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.double_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.double_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.double_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.double_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.double_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b eql_v3.double_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a jsonb +--! @param b eql_v3.double_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.double_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_functions.sql +--! @brief Functions for eql_v3.double_ord. + +--! @brief Index extractor for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.double_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.double_ord, b eql_v3.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.double_ord) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a jsonb +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.double_ord, b eql_v3.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.double_ord) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a jsonb +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.double_ord, b eql_v3.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.double_ord) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a jsonb +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.double_ord, b eql_v3.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.double_ord) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a jsonb +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.double_ord, b eql_v3.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.double_ord) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a jsonb +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.double_ord, b eql_v3.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.double_ord) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a jsonb +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_ord, b eql_v3.double_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a jsonb +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.double_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_ord, b eql_v3.double_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a jsonb +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.double_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param selector text +--! @return eql_v3.double_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_ord, selector text) +RETURNS eql_v3.double_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param selector integer +--! @return eql_v3.double_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_ord, selector integer) +RETURNS eql_v3.double_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a jsonb +--! @param selector eql_v3.double_ord +--! @return eql_v3.double_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.double_ord) +RETURNS eql_v3.double_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a jsonb +--! @param selector eql_v3.double_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.double_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.double_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.double_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.double_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.double_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.double_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.double_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.double_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.double_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b eql_v3.double_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_ord, b eql_v3.double_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a jsonb +--! @param b eql_v3.double_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.double_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ore_functions.sql +--! @brief Functions for eql_v3.date_ord_ore. + +--! @brief Index extractor for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a 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 eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.date_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.date_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.date_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.date_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.date_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a 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::eql_v3.date_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.date_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a 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::eql_v3.date_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.date_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a 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::eql_v3.date_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.date_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a 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::eql_v3.date_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.date_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.date_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param selector text +--! @return eql_v3.date_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_ord_ore, selector text) +RETURNS eql_v3.date_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param selector integer +--! @return eql_v3.date_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_ord_ore, selector integer) +RETURNS eql_v3.date_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.date_ord_ore +--! @return eql_v3.date_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.date_ord_ore) +RETURNS eql_v3.date_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.date_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.date_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.date_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.date_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.date_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.date_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.date_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.date_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.date_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.date_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b eql_v3.date_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param b eql_v3.date_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.date_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ope_functions.sql +--! @brief Functions for eql_v3.date_ord_ope. + +--! @brief Index extractor for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a 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 eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.date_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.date_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a jsonb +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.date_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.date_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.date_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a jsonb +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.date_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.date_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.date_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a jsonb +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.date_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.date_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.date_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a jsonb +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.date_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.date_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.date_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a jsonb +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.date_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.date_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.date_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a jsonb +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.date_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a jsonb +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.date_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a jsonb +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.date_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param selector text +--! @return eql_v3.date_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_ord_ope, selector text) +RETURNS eql_v3.date_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param selector integer +--! @return eql_v3.date_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_ord_ope, selector integer) +RETURNS eql_v3.date_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.date_ord_ope +--! @return eql_v3.date_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.date_ord_ope) +RETURNS eql_v3.date_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.date_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.date_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.date_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.date_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.date_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.date_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.date_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.date_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.date_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.date_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b eql_v3.date_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a jsonb +--! @param b eql_v3.date_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.date_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_functions.sql +--! @brief Functions for eql_v3.date_ord. + +--! @brief Index extractor for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.date_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.date_ord, b 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.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.date_ord) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a jsonb +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.date_ord, b 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.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.date_ord) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a jsonb +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.date_ord, b 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.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a 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::eql_v3.date_ord) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a jsonb +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.date_ord, b 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.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a 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::eql_v3.date_ord) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a jsonb +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.date_ord, b 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.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a 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::eql_v3.date_ord) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a jsonb +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.date_ord, b 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.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a 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::eql_v3.date_ord) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a jsonb +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_ord, b eql_v3.date_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a jsonb +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.date_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_ord, b eql_v3.date_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a jsonb +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.date_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param selector text +--! @return eql_v3.date_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_ord, selector text) +RETURNS eql_v3.date_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param selector integer +--! @return eql_v3.date_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_ord, selector integer) +RETURNS eql_v3.date_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a jsonb +--! @param selector eql_v3.date_ord +--! @return eql_v3.date_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.date_ord) +RETURNS eql_v3.date_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a jsonb +--! @param selector eql_v3.date_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.date_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.date_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.date_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.date_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.date_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.date_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.date_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.date_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.date_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b eql_v3.date_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_ord, b eql_v3.date_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a jsonb +--! @param b eql_v3.date_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.date_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/boolean/boolean_types.sql +--! @brief Encrypted-domain types for boolean. + +DO $$ +BEGIN + --! @brief Encrypted domain eql_v3.boolean. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'boolean' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ore_functions.sql +--! @brief Functions for eql_v3.bigint_ord_ore. + +--! @brief Index extractor for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a 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 Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.bigint_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.bigint_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.bigint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.bigint_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.bigint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.bigint_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.bigint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.bigint_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.bigint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.bigint_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param selector text +--! @return eql_v3.bigint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_ord_ore, selector text) +RETURNS eql_v3.bigint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param selector integer +--! @return eql_v3.bigint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_ord_ore, selector integer) +RETURNS eql_v3.bigint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.bigint_ord_ore +--! @return eql_v3.bigint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.bigint_ord_ore) +RETURNS eql_v3.bigint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.bigint_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.bigint_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.bigint_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.bigint_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.bigint_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.bigint_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.bigint_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.bigint_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.bigint_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.bigint_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b eql_v3.bigint_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.bigint_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ope_functions.sql +--! @brief Functions for eql_v3.bigint_ord_ope. + +--! @brief Index extractor for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a 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 eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.bigint_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.bigint_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.bigint_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.bigint_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.bigint_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.bigint_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.bigint_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.bigint_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.bigint_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.bigint_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.bigint_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.bigint_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.bigint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.bigint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param selector text +--! @return eql_v3.bigint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_ord_ope, selector text) +RETURNS eql_v3.bigint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param selector integer +--! @return eql_v3.bigint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_ord_ope, selector integer) +RETURNS eql_v3.bigint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.bigint_ord_ope +--! @return eql_v3.bigint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.bigint_ord_ope) +RETURNS eql_v3.bigint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.bigint_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.bigint_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.bigint_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.bigint_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.bigint_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.bigint_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.bigint_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.bigint_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.bigint_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.bigint_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b eql_v3.bigint_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.bigint_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_functions.sql +--! @brief Functions for eql_v3.bigint_ord. + +--! @brief Index extractor for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.bigint_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_ord, b 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 Operator wrapper for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.bigint_ord) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord. +--! @param a jsonb +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_ord, b 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 Operator wrapper for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.bigint_ord) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord. +--! @param a jsonb +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.bigint_ord, b 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 Operator wrapper for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a 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::eql_v3.bigint_ord) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord. +--! @param a jsonb +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.bigint_ord, b 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 Operator wrapper for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a 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::eql_v3.bigint_ord) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord. +--! @param a jsonb +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.bigint_ord, b 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 Operator wrapper for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a 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::eql_v3.bigint_ord) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord. +--! @param a jsonb +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.bigint_ord, b 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 Operator wrapper for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a 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::eql_v3.bigint_ord) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord. +--! @param a jsonb +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_ord, b eql_v3.bigint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a jsonb +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.bigint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_ord, b eql_v3.bigint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a jsonb +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.bigint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param selector text +--! @return eql_v3.bigint_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_ord, selector text) +RETURNS eql_v3.bigint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param selector integer +--! @return eql_v3.bigint_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_ord, selector integer) +RETURNS eql_v3.bigint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a jsonb +--! @param selector eql_v3.bigint_ord +--! @return eql_v3.bigint_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.bigint_ord) +RETURNS eql_v3.bigint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a jsonb +--! @param selector eql_v3.bigint_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.bigint_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.bigint_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.bigint_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.bigint_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.bigint_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.bigint_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.bigint_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.bigint_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.bigint_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b eql_v3.bigint_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_ord, b eql_v3.bigint_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a jsonb +--! @param b eql_v3.bigint_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.bigint_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @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): +--! - eql_v3.json — storage/root: an EQL envelope object ({i, v, ...}). +--! - eql_v3.jsonb_entry — a single sv element (returned by `->`). +--! - eql_v3.jsonb_query — 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 `oc`). +CREATE FUNCTION eql_v3_internal.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 ? 'oc')) + OR + (jsonb_typeof(val -> 'oc') = 'string' AND NOT (val ? 'hm')) + ), + false + ) +$$; + +--! @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 +--! `oc`). +CREATE FUNCTION eql_v3_internal.is_valid_ste_vec_query_payload(val jsonb) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT 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 ? 'oc')) + OR + (jsonb_typeof(elem -> 'oc') = 'string' AND NOT (elem ? 'hm')) + ) + ), false) + ), + false + ) +$$; + +--! @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 FUNCTION eql_v3_internal.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 eql_v3_internal.is_valid_ste_vec_entry_payload(elem) + ), + false + ) +$$; + +--! @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 `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":[...]}'::eql_v3.json`. +CREATE DOMAIN eql_v3.json AS jsonb + CHECK ( + eql_v3_internal.is_valid_ste_vec_document_payload(VALUE) + ); + +--! @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 `oc` (CLLW ORE, 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.ore_cllw`. Extra fields (`a`, root +--! `i`/`v` merged in by `->`) are allowed. +--! +--! @see src/v3/jsonb/operators.sql +CREATE DOMAIN eql_v3.jsonb_entry AS jsonb + CHECK ( + eql_v3_internal.is_valid_ste_vec_entry_payload(VALUE) + ); + +--! @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 `oc`). 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":"<sel>","hm":"<hm>"}]}'::eql_v3.jsonb_query`. +--! @see eql_v3.to_ste_vec_query +CREATE DOMAIN eql_v3.jsonb_query AS jsonb + CHECK ( + eql_v3_internal.is_valid_ste_vec_query_payload(VALUE) + ); + +--! @brief Convert an eql_v3.json to a jsonb_query needle. +--! +--! Normalises each sv element down to the matching-relevant fields: `s` plus +--! exactly one of `hm` / `oc`. Other fields (`c`, `a`, `i`/`v`, anything else) +--! 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 eql_v3.json Source encrypted payload +--! @return eql_v3.jsonb_query Query-shaped needle, sv elements normalised. +--! @see eql_v3.jsonb_query +CREATE FUNCTION eql_v3.to_ste_vec_query(e eql_v3.json) + RETURNS eql_v3.jsonb_query + 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', + 'oc', elem -> 'oc' + ) + ) + ) + FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem), + '[]'::jsonb + ) + )::eql_v3.jsonb_query +$$; + +CREATE CAST (eql_v3.json AS eql_v3.jsonb_query) + WITH FUNCTION eql_v3.to_ste_vec_query + AS ASSIGNMENT; + +--! @file v3/sem/ore_cllw/operators.sql +--! @brief Comparison operators on the eql_v3_internal.ore_cllw composite type. +--! +--! Each backing function reduces to a single SELECT over +--! eql_v3_internal.compare_ore_cllw_term(a, b) and is inlinable so the planner can fold +--! it through to functional-index matching. The inner comparator is plpgsql +--! (per-byte loop) and is not inlined — fine for index *match*. +--! +--! @note Deliberately no HASHES / MERGES — the CLLW protocol gives ordering, +--! not a hash; there is no merge-joinable opclass on the other side. +--! @see eql_v3_internal.compare_ore_cllw_term + +--! @brief Equality backing function for eql_v3_internal.ore_cllw. +--! @internal +--! +--! @param a eql_v3_internal.ore_cllw Left operand +--! @param b eql_v3_internal.ore_cllw Right operand +--! @return boolean True if the CLLW ORE terms are equal +--! +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.ore_cllw_eq(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_cllw_term(a, b) = 0 +$$; + +--! @brief Not-equal backing function for eql_v3_internal.ore_cllw. +--! @internal +--! +--! @param a eql_v3_internal.ore_cllw Left operand +--! @param b eql_v3_internal.ore_cllw Right operand +--! @return boolean True if the CLLW ORE terms are not equal +--! +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.ore_cllw_neq(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_cllw_term(a, b) <> 0 +$$; + +--! @brief Less-than backing function for eql_v3_internal.ore_cllw. +--! @internal +--! +--! @param a eql_v3_internal.ore_cllw Left operand +--! @param b eql_v3_internal.ore_cllw Right operand +--! @return boolean True if the left operand is less than the right operand +--! +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.ore_cllw_lt(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_cllw_term(a, b) = -1 +$$; + +--! @brief Less-than-or-equal backing function for eql_v3_internal.ore_cllw. +--! @internal +--! +--! @param a eql_v3_internal.ore_cllw Left operand +--! @param b eql_v3_internal.ore_cllw Right operand +--! @return boolean True if the left operand is less than or equal to the right operand +--! +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.ore_cllw_lte(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_cllw_term(a, b) <> 1 +$$; + +--! @brief Greater-than backing function for eql_v3_internal.ore_cllw. +--! @internal +--! +--! @param a eql_v3_internal.ore_cllw Left operand +--! @param b eql_v3_internal.ore_cllw Right operand +--! @return boolean True if the left operand is greater than the right operand +--! +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.ore_cllw_gt(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_cllw_term(a, b) = 1 +$$; + +--! @brief Greater-than-or-equal backing function for eql_v3_internal.ore_cllw. +--! @internal +--! +--! @param a eql_v3_internal.ore_cllw Left operand +--! @param b eql_v3_internal.ore_cllw Right operand +--! @return boolean True if the left operand is greater than or equal to the right operand +--! +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.ore_cllw_gte(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_cllw_term(a, b) <> -1 +$$; + + +CREATE OPERATOR public.= ( + FUNCTION = eql_v3_internal.ore_cllw_eq, + LEFTARG = eql_v3_internal.ore_cllw, + RIGHTARG = eql_v3_internal.ore_cllw, + COMMUTATOR = OPERATOR(public.=), + NEGATOR = OPERATOR(public.<>), + RESTRICT = eqsel, + JOIN = eqjoinsel +); + +CREATE OPERATOR public.<> ( + FUNCTION = eql_v3_internal.ore_cllw_neq, + LEFTARG = eql_v3_internal.ore_cllw, + RIGHTARG = eql_v3_internal.ore_cllw, + COMMUTATOR = OPERATOR(public.<>), + NEGATOR = OPERATOR(public.=), + RESTRICT = neqsel, + JOIN = neqjoinsel +); + +CREATE OPERATOR public.< ( + FUNCTION = eql_v3_internal.ore_cllw_lt, + LEFTARG = eql_v3_internal.ore_cllw, + RIGHTARG = eql_v3_internal.ore_cllw, + COMMUTATOR = OPERATOR(public.>), + NEGATOR = OPERATOR(public.>=), + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel +); + +CREATE OPERATOR public.<= ( + FUNCTION = eql_v3_internal.ore_cllw_lte, + LEFTARG = eql_v3_internal.ore_cllw, + RIGHTARG = eql_v3_internal.ore_cllw, + COMMUTATOR = OPERATOR(public.>=), + NEGATOR = OPERATOR(public.>), + RESTRICT = scalarlesel, + JOIN = scalarlejoinsel +); + +CREATE OPERATOR public.> ( + FUNCTION = eql_v3_internal.ore_cllw_gt, + LEFTARG = eql_v3_internal.ore_cllw, + RIGHTARG = eql_v3_internal.ore_cllw, + COMMUTATOR = OPERATOR(public.<), + NEGATOR = OPERATOR(public.<=), + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel +); + +CREATE OPERATOR public.>= ( + FUNCTION = eql_v3_internal.ore_cllw_gte, + LEFTARG = eql_v3_internal.ore_cllw, + RIGHTARG = eql_v3_internal.ore_cllw, + COMMUTATOR = OPERATOR(public.<=), + NEGATOR = OPERATOR(public.<), + RESTRICT = scalargesel, + JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ore_operators.sql +--! @brief Operators for eql_v3.timestamp_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ope_operators.sql +--! @brief Operators for eql_v3.timestamp_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_operators.sql +--! @brief Operators for eql_v3.timestamp_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_functions.sql +--! @brief Functions for eql_v3.timestamp. + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.timestamp, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a jsonb +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.timestamp, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a jsonb +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.timestamp, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a jsonb +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.timestamp, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a jsonb +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.timestamp, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a jsonb +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.timestamp, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a jsonb +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a jsonb +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a jsonb +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param selector text +--! @return eql_v3.timestamp +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp, selector text) +RETURNS eql_v3.timestamp IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param selector integer +--! @return eql_v3.timestamp +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp, selector integer) +RETURNS eql_v3.timestamp IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a jsonb +--! @param selector eql_v3.timestamp +--! @return eql_v3.timestamp +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.timestamp) +RETURNS eql_v3.timestamp IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a jsonb +--! @param selector eql_v3.timestamp +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.timestamp) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.timestamp, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.timestamp, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.timestamp, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.timestamp, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.timestamp, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.timestamp, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.timestamp, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.timestamp, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b eql_v3.timestamp +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp, b eql_v3.timestamp) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a jsonb +--! @param b eql_v3.timestamp +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.timestamp) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_eq_functions.sql +--! @brief Functions for eql_v3.timestamp_eq. + +--! @brief Index extractor for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.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.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_eq, b 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.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.timestamp_eq) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_eq. +--! @param a jsonb +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.timestamp_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.timestamp_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_eq, b 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.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.timestamp_eq) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_eq. +--! @param a jsonb +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.timestamp_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.timestamp_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a jsonb +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a jsonb +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a jsonb +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a jsonb +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a jsonb +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a jsonb +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param selector text +--! @return eql_v3.timestamp_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_eq, selector text) +RETURNS eql_v3.timestamp_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param selector integer +--! @return eql_v3.timestamp_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_eq, selector integer) +RETURNS eql_v3.timestamp_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a jsonb +--! @param selector eql_v3.timestamp_eq +--! @return eql_v3.timestamp_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.timestamp_eq) +RETURNS eql_v3.timestamp_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a jsonb +--! @param selector eql_v3.timestamp_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.timestamp_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.timestamp_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.timestamp_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.timestamp_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.timestamp_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.timestamp_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.timestamp_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.timestamp_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.timestamp_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b eql_v3.timestamp_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a jsonb +--! @param b eql_v3.timestamp_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.timestamp_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_search_operators.sql +--! @brief Operators for eql_v3.text_search. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text_search, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text_search, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text_search, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text_search, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.text_search, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.text_search, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.text_search, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.text_search, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.text_search, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.text_search, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.text_search, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_search, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_search, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_search, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.text_search, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text_search, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ore_operators.sql +--! @brief Operators for eql_v3.text_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ope_operators.sql +--! @brief Operators for eql_v3.text_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_operators.sql +--! @brief Operators for eql_v3.text_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.text_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.text_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.text_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.text_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.text_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.text_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_functions.sql +--! @brief Functions for eql_v3.text. + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.text, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a jsonb +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.text, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a jsonb +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.text, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a jsonb +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.text, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a jsonb +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.text, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a jsonb +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.text, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a jsonb +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a jsonb +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a jsonb +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param selector text +--! @return eql_v3.text +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text, selector text) +RETURNS eql_v3.text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param selector integer +--! @return eql_v3.text +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text, selector integer) +RETURNS eql_v3.text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a jsonb +--! @param selector eql_v3.text +--! @return eql_v3.text +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text) +RETURNS eql_v3.text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a jsonb +--! @param selector eql_v3.text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b eql_v3.text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text, b eql_v3.text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a jsonb +--! @param b eql_v3.text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_match_functions.sql +--! @brief Functions for eql_v3.text_match. + +--! @brief Index extractor for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @return eql_v3_internal.bloom_filter +CREATE FUNCTION eql_v3.match_term(a 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 eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.text_match, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a jsonb +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.text_match, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a jsonb +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.text_match, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a jsonb +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.text_match, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a jsonb +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.text_match, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a jsonb +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.text_match, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a jsonb +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Operator wrapper for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.text_match, b 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.text_match. +--! @param a eql_v3.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(a 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::eql_v3.text_match) $$; + +--! @brief Operator wrapper for eql_v3.text_match. +--! @param a jsonb +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::eql_v3.text_match) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.text_match, b 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.text_match. +--! @param a eql_v3.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a 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::eql_v3.text_match) $$; + +--! @brief Operator wrapper for eql_v3.text_match. +--! @param a jsonb +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::eql_v3.text_match) <@ eql_v3.match_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param selector text +--! @return eql_v3.text_match +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_match, selector text) +RETURNS eql_v3.text_match IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param selector integer +--! @return eql_v3.text_match +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_match, selector integer) +RETURNS eql_v3.text_match IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a jsonb +--! @param selector eql_v3.text_match +--! @return eql_v3.text_match +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text_match) +RETURNS eql_v3.text_match IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_match, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_match, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a jsonb +--! @param selector eql_v3.text_match +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text_match) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text_match, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text_match, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text_match, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text_match, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text_match, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text_match, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text_match, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_match, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_match, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_match, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text_match, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b eql_v3.text_match +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_match, b eql_v3.text_match) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_match, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a jsonb +--! @param b eql_v3.text_match +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text_match) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_eq_functions.sql +--! @brief Functions for eql_v3.text_eq. + +--! @brief Index extractor for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a 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 eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.text_eq, b 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 Operator wrapper for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.text_eq) $$; + +--! @brief Operator wrapper for eql_v3.text_eq. +--! @param a jsonb +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.text_eq, b 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 Operator wrapper for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.text_eq) $$; + +--! @brief Operator wrapper for eql_v3.text_eq. +--! @param a jsonb +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.text_eq, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a jsonb +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.text_eq, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a jsonb +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.text_eq, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a jsonb +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.text_eq, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a jsonb +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_eq, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a jsonb +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_eq, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a jsonb +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param selector text +--! @return eql_v3.text_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_eq, selector text) +RETURNS eql_v3.text_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param selector integer +--! @return eql_v3.text_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_eq, selector integer) +RETURNS eql_v3.text_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a jsonb +--! @param selector eql_v3.text_eq +--! @return eql_v3.text_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text_eq) +RETURNS eql_v3.text_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a jsonb +--! @param selector eql_v3.text_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b eql_v3.text_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_eq, b eql_v3.text_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a jsonb +--! @param b eql_v3.text_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ore_operators.sql +--! @brief Operators for eql_v3.smallint_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ope_operators.sql +--! @brief Operators for eql_v3.smallint_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_operators.sql +--! @brief Operators for eql_v3.smallint_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_functions.sql +--! @brief Functions for eql_v3.smallint. + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.smallint, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a jsonb +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.smallint, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a jsonb +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.smallint, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a jsonb +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.smallint, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a jsonb +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.smallint, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a jsonb +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.smallint, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a jsonb +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a jsonb +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a jsonb +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param selector text +--! @return eql_v3.smallint +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint, selector text) +RETURNS eql_v3.smallint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param selector integer +--! @return eql_v3.smallint +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint, selector integer) +RETURNS eql_v3.smallint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a jsonb +--! @param selector eql_v3.smallint +--! @return eql_v3.smallint +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.smallint) +RETURNS eql_v3.smallint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a jsonb +--! @param selector eql_v3.smallint +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.smallint) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.smallint, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.smallint, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.smallint, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.smallint, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.smallint, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.smallint, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.smallint, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.smallint, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b eql_v3.smallint +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint, b eql_v3.smallint) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a jsonb +--! @param b eql_v3.smallint +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.smallint) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_eq_functions.sql +--! @brief Functions for eql_v3.smallint_eq. + +--! @brief Index extractor for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a 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 Operator wrapper for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_eq, b 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.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.smallint_eq) $$; + +--! @brief Operator wrapper for eql_v3.smallint_eq. +--! @param a jsonb +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.smallint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.smallint_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_eq, b 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.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.smallint_eq) $$; + +--! @brief Operator wrapper for eql_v3.smallint_eq. +--! @param a jsonb +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.smallint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.smallint_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.smallint_eq, b eql_v3.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a jsonb +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.smallint_eq, b eql_v3.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a jsonb +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.smallint_eq, b eql_v3.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a jsonb +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.smallint_eq, b eql_v3.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a jsonb +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_eq, b eql_v3.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a jsonb +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_eq, b eql_v3.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a jsonb +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param selector text +--! @return eql_v3.smallint_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_eq, selector text) +RETURNS eql_v3.smallint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param selector integer +--! @return eql_v3.smallint_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_eq, selector integer) +RETURNS eql_v3.smallint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a jsonb +--! @param selector eql_v3.smallint_eq +--! @return eql_v3.smallint_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.smallint_eq) +RETURNS eql_v3.smallint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a jsonb +--! @param selector eql_v3.smallint_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.smallint_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.smallint_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.smallint_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.smallint_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.smallint_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.smallint_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.smallint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.smallint_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.smallint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b eql_v3.smallint_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_eq, b eql_v3.smallint_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a jsonb +--! @param b eql_v3.smallint_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.smallint_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ore_operators.sql +--! @brief Operators for eql_v3.real_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ope_operators.sql +--! @brief Operators for eql_v3.real_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_operators.sql +--! @brief Operators for eql_v3.real_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.real_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.real_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.real_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.real_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.real_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.real_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.real_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.real_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.real_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.real_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.real_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.real_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_functions.sql +--! @brief Functions for eql_v3.real. + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.real, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a jsonb +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.real, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a jsonb +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.real, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a jsonb +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.real, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a jsonb +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.real, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a jsonb +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.real, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a jsonb +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a jsonb +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a jsonb +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param selector text +--! @return eql_v3.real +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real, selector text) +RETURNS eql_v3.real IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param selector integer +--! @return eql_v3.real +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real, selector integer) +RETURNS eql_v3.real IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a jsonb +--! @param selector eql_v3.real +--! @return eql_v3.real +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.real) +RETURNS eql_v3.real IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a jsonb +--! @param selector eql_v3.real +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.real) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.real, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.real, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.real, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.real, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.real, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.real, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.real, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.real, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b eql_v3.real +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real, b eql_v3.real) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a jsonb +--! @param b eql_v3.real +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.real) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_eq_functions.sql +--! @brief Functions for eql_v3.real_eq. + +--! @brief Index extractor for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a 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 Operator wrapper for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.real_eq, b 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.real_eq. +--! @param a eql_v3.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.real_eq) $$; + +--! @brief Operator wrapper for eql_v3.real_eq. +--! @param a jsonb +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.real_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.real_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.real_eq, b 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.real_eq. +--! @param a eql_v3.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.real_eq) $$; + +--! @brief Operator wrapper for eql_v3.real_eq. +--! @param a jsonb +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.real_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.real_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.real_eq, b eql_v3.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a jsonb +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.real_eq, b eql_v3.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a jsonb +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.real_eq, b eql_v3.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a jsonb +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.real_eq, b eql_v3.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a jsonb +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_eq, b eql_v3.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a jsonb +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_eq, b eql_v3.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a jsonb +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param selector text +--! @return eql_v3.real_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_eq, selector text) +RETURNS eql_v3.real_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param selector integer +--! @return eql_v3.real_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_eq, selector integer) +RETURNS eql_v3.real_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a jsonb +--! @param selector eql_v3.real_eq +--! @return eql_v3.real_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.real_eq) +RETURNS eql_v3.real_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a jsonb +--! @param selector eql_v3.real_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.real_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.real_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.real_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.real_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.real_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.real_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.real_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.real_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.real_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b eql_v3.real_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_eq, b eql_v3.real_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a jsonb +--! @param b eql_v3.real_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.real_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ore_operators.sql +--! @brief Operators for eql_v3.numeric_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ope_operators.sql +--! @brief Operators for eql_v3.numeric_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_operators.sql +--! @brief Operators for eql_v3.numeric_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_functions.sql +--! @brief Functions for eql_v3.numeric. + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.numeric, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.numeric, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.numeric, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.numeric, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.numeric, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.numeric, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param selector text +--! @return eql_v3.numeric +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric, selector text) +RETURNS eql_v3.numeric IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param selector integer +--! @return eql_v3.numeric +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric, selector integer) +RETURNS eql_v3.numeric IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param selector eql_v3.numeric +--! @return eql_v3.numeric +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.numeric) +RETURNS eql_v3.numeric IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param selector eql_v3.numeric +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.numeric) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.numeric, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.numeric, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.numeric, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.numeric, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.numeric, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.numeric, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.numeric, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.numeric, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b eql_v3.numeric +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric, b eql_v3.numeric) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param b eql_v3.numeric +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.numeric) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_eq_functions.sql +--! @brief Functions for eql_v3.numeric_eq. + +--! @brief Index extractor for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.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.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_eq, b 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.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.numeric_eq) $$; + +--! @brief Operator wrapper for eql_v3.numeric_eq. +--! @param a jsonb +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.numeric_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.numeric_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_eq, b 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.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.numeric_eq) $$; + +--! @brief Operator wrapper for eql_v3.numeric_eq. +--! @param a jsonb +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.numeric_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.numeric_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.numeric_eq, b eql_v3.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a jsonb +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.numeric_eq, b eql_v3.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a jsonb +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.numeric_eq, b eql_v3.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a jsonb +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.numeric_eq, b eql_v3.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a jsonb +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_eq, b eql_v3.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a jsonb +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_eq, b eql_v3.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a jsonb +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param selector text +--! @return eql_v3.numeric_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_eq, selector text) +RETURNS eql_v3.numeric_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param selector integer +--! @return eql_v3.numeric_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_eq, selector integer) +RETURNS eql_v3.numeric_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a jsonb +--! @param selector eql_v3.numeric_eq +--! @return eql_v3.numeric_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.numeric_eq) +RETURNS eql_v3.numeric_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a jsonb +--! @param selector eql_v3.numeric_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.numeric_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.numeric_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.numeric_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.numeric_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.numeric_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.numeric_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.numeric_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.numeric_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.numeric_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b eql_v3.numeric_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_eq, b eql_v3.numeric_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a jsonb +--! @param b eql_v3.numeric_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.numeric_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ore_operators.sql +--! @brief Operators for eql_v3.integer_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ope_operators.sql +--! @brief Operators for eql_v3.integer_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_operators.sql +--! @brief Operators for eql_v3.integer_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.integer_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.integer_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.integer_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.integer_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.integer_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_functions.sql +--! @brief Functions for eql_v3.integer. + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.integer, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a jsonb +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.integer, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a jsonb +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.integer, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a jsonb +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.integer, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a jsonb +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.integer, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a jsonb +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.integer, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a jsonb +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a jsonb +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a jsonb +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param selector text +--! @return eql_v3.integer +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer, selector text) +RETURNS eql_v3.integer IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param selector integer +--! @return eql_v3.integer +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer, selector integer) +RETURNS eql_v3.integer IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a jsonb +--! @param selector eql_v3.integer +--! @return eql_v3.integer +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.integer) +RETURNS eql_v3.integer IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a jsonb +--! @param selector eql_v3.integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.integer, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.integer, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.integer, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.integer, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.integer, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.integer, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.integer, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.integer, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b eql_v3.integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer, b eql_v3.integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a jsonb +--! @param b eql_v3.integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_eq_functions.sql +--! @brief Functions for eql_v3.integer_eq. + +--! @brief Index extractor for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a 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 eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.integer_eq, b 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 eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.integer_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.integer_eq) $$; + +--! @brief Operator wrapper for eql_v3.integer_eq. +--! @param a jsonb +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.integer_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.integer_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.integer_eq, b 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 eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.integer_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.integer_eq) $$; + +--! @brief Operator wrapper for eql_v3.integer_eq. +--! @param a jsonb +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.integer_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.integer_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.integer_eq, b eql_v3.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a jsonb +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.integer_eq, b eql_v3.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a jsonb +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.integer_eq, b eql_v3.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a jsonb +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.integer_eq, b eql_v3.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a jsonb +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_eq, b eql_v3.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a jsonb +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_eq, b eql_v3.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a jsonb +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param selector text +--! @return eql_v3.integer_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_eq, selector text) +RETURNS eql_v3.integer_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param selector integer +--! @return eql_v3.integer_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_eq, selector integer) +RETURNS eql_v3.integer_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a jsonb +--! @param selector eql_v3.integer_eq +--! @return eql_v3.integer_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.integer_eq) +RETURNS eql_v3.integer_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a jsonb +--! @param selector eql_v3.integer_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.integer_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.integer_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.integer_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.integer_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.integer_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.integer_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.integer_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.integer_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.integer_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b eql_v3.integer_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_eq, b eql_v3.integer_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a jsonb +--! @param b eql_v3.integer_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.integer_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ore_operators.sql +--! @brief Operators for eql_v3.double_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ope_operators.sql +--! @brief Operators for eql_v3.double_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_operators.sql +--! @brief Operators for eql_v3.double_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.double_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.double_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.double_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.double_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.double_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.double_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.double_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.double_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.double_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.double_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.double_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.double_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_functions.sql +--! @brief Functions for eql_v3.double. + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.double, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a jsonb +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.double, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a jsonb +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.double, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a jsonb +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.double, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a jsonb +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.double, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a jsonb +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.double, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a jsonb +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a jsonb +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a jsonb +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param selector text +--! @return eql_v3.double +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double, selector text) +RETURNS eql_v3.double IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param selector integer +--! @return eql_v3.double +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double, selector integer) +RETURNS eql_v3.double IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a jsonb +--! @param selector eql_v3.double +--! @return eql_v3.double +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.double) +RETURNS eql_v3.double IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a jsonb +--! @param selector eql_v3.double +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.double) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.double, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.double, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.double, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.double, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.double, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.double, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.double, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.double, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b eql_v3.double +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double, b eql_v3.double) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a jsonb +--! @param b eql_v3.double +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.double) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_eq_functions.sql +--! @brief Functions for eql_v3.double_eq. + +--! @brief Index extractor for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a 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 eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.double_eq, b 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 eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.double_eq) $$; + +--! @brief Operator wrapper for eql_v3.double_eq. +--! @param a jsonb +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.double_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.double_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.double_eq, b 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 eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.double_eq) $$; + +--! @brief Operator wrapper for eql_v3.double_eq. +--! @param a jsonb +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.double_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.double_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.double_eq, b eql_v3.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a jsonb +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.double_eq, b eql_v3.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a jsonb +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.double_eq, b eql_v3.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a jsonb +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.double_eq, b eql_v3.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a jsonb +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_eq, b eql_v3.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a jsonb +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_eq, b eql_v3.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a jsonb +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param selector text +--! @return eql_v3.double_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_eq, selector text) +RETURNS eql_v3.double_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param selector integer +--! @return eql_v3.double_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_eq, selector integer) +RETURNS eql_v3.double_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a jsonb +--! @param selector eql_v3.double_eq +--! @return eql_v3.double_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.double_eq) +RETURNS eql_v3.double_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a jsonb +--! @param selector eql_v3.double_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.double_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.double_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.double_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.double_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.double_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.double_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.double_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.double_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.double_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b eql_v3.double_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_eq, b eql_v3.double_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a jsonb +--! @param b eql_v3.double_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.double_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ore_operators.sql +--! @brief Operators for eql_v3.date_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ope_operators.sql +--! @brief Operators for eql_v3.date_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_operators.sql +--! @brief Operators for eql_v3.date_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.date_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.date_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.date_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.date_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.date_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_functions.sql +--! @brief Functions for eql_v3.date. + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.date, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.date, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.date, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.date, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.date, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.date, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param selector text +--! @return eql_v3.date +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date, selector text) +RETURNS eql_v3.date IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param selector integer +--! @return eql_v3.date +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date, selector integer) +RETURNS eql_v3.date IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param selector eql_v3.date +--! @return eql_v3.date +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.date) +RETURNS eql_v3.date IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param selector eql_v3.date +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.date) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.date, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.date, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.date, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.date, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.date, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.date, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.date, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.date, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b eql_v3.date +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date, b eql_v3.date) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param b eql_v3.date +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.date) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_eq_functions.sql +--! @brief Functions for eql_v3.date_eq. + +--! @brief Index extractor for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a 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 eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.date_eq, b 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.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.date_eq) $$; + +--! @brief Operator wrapper for eql_v3.date_eq. +--! @param a jsonb +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.date_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.date_eq, b 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.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.date_eq) $$; + +--! @brief Operator wrapper for eql_v3.date_eq. +--! @param a jsonb +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.date_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.date_eq, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a jsonb +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.date_eq, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a jsonb +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.date_eq, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a jsonb +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.date_eq, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a jsonb +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_eq, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a jsonb +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_eq, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a jsonb +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param selector text +--! @return eql_v3.date_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_eq, selector text) +RETURNS eql_v3.date_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param selector integer +--! @return eql_v3.date_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_eq, selector integer) +RETURNS eql_v3.date_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a jsonb +--! @param selector eql_v3.date_eq +--! @return eql_v3.date_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.date_eq) +RETURNS eql_v3.date_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a jsonb +--! @param selector eql_v3.date_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.date_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.date_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.date_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.date_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.date_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.date_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.date_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.date_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.date_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b eql_v3.date_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_eq, b eql_v3.date_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a jsonb +--! @param b eql_v3.date_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.date_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/boolean/boolean_functions.sql +--! @brief Functions for eql_v3.boolean. + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.boolean, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a jsonb +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.boolean, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a jsonb +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.boolean, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a jsonb +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.boolean, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a jsonb +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.boolean, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a jsonb +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.boolean, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a jsonb +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.boolean, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a jsonb +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.boolean, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a jsonb +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param selector text +--! @return eql_v3.boolean +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.boolean, selector text) +RETURNS eql_v3.boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param selector integer +--! @return eql_v3.boolean +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.boolean, selector integer) +RETURNS eql_v3.boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a jsonb +--! @param selector eql_v3.boolean +--! @return eql_v3.boolean +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.boolean) +RETURNS eql_v3.boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.boolean, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.boolean, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a jsonb +--! @param selector eql_v3.boolean +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.boolean) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.boolean, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.boolean, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.boolean, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.boolean, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.boolean, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.boolean, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.boolean, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.boolean, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.boolean, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.boolean, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.boolean, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b eql_v3.boolean +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.boolean, b eql_v3.boolean) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.boolean, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a jsonb +--! @param b eql_v3.boolean +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.boolean) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ore_operators.sql +--! @brief Operators for eql_v3.bigint_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ope_operators.sql +--! @brief Operators for eql_v3.bigint_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_operators.sql +--! @brief Operators for eql_v3.bigint_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_functions.sql +--! @brief Functions for eql_v3.bigint. + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.bigint, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a jsonb +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.bigint, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a jsonb +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.bigint, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a jsonb +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.bigint, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a jsonb +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.bigint, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a jsonb +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.bigint, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a jsonb +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a jsonb +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a jsonb +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param selector text +--! @return eql_v3.bigint +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint, selector text) +RETURNS eql_v3.bigint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param selector integer +--! @return eql_v3.bigint +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint, selector integer) +RETURNS eql_v3.bigint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a jsonb +--! @param selector eql_v3.bigint +--! @return eql_v3.bigint +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.bigint) +RETURNS eql_v3.bigint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a jsonb +--! @param selector eql_v3.bigint +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.bigint) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.bigint, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.bigint, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.bigint, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.bigint, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.bigint, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.bigint, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.bigint, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.bigint, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b eql_v3.bigint +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint, b eql_v3.bigint) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a jsonb +--! @param b eql_v3.bigint +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.bigint) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_eq_functions.sql +--! @brief Functions for eql_v3.bigint_eq. + +--! @brief Index extractor for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a 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 eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_eq, b 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 eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.bigint_eq) $$; + +--! @brief Operator wrapper for eql_v3.bigint_eq. +--! @param a jsonb +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.bigint_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_eq, b 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 eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.bigint_eq) $$; + +--! @brief Operator wrapper for eql_v3.bigint_eq. +--! @param a jsonb +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.bigint_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.bigint_eq, b eql_v3.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a jsonb +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.bigint_eq, b eql_v3.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a jsonb +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.bigint_eq, b eql_v3.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a jsonb +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.bigint_eq, b eql_v3.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a jsonb +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_eq, b eql_v3.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a jsonb +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_eq, b eql_v3.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a jsonb +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param selector text +--! @return eql_v3.bigint_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_eq, selector text) +RETURNS eql_v3.bigint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param selector integer +--! @return eql_v3.bigint_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_eq, selector integer) +RETURNS eql_v3.bigint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a jsonb +--! @param selector eql_v3.bigint_eq +--! @return eql_v3.bigint_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.bigint_eq) +RETURNS eql_v3.bigint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a jsonb +--! @param selector eql_v3.bigint_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.bigint_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.bigint_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.bigint_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.bigint_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.bigint_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.bigint_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.bigint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.bigint_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.bigint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b eql_v3.bigint_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_eq, b eql_v3.bigint_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a jsonb +--! @param b eql_v3.bigint_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.bigint_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @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. + +------------------------------------------------------------------------------ +-- Envelope helpers (eql_v3 owns these; jsonb-only) +------------------------------------------------------------------------------ + +--! @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'); +$$; + +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)'; + +--! @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; + +------------------------------------------------------------------------------ +-- Selector extractors +------------------------------------------------------------------------------ + +--! @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; + +--! @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 eql_v3.jsonb_entry +--! @return text The selector value. +CREATE FUNCTION eql_v3.selector(entry eql_v3.jsonb_entry) + RETURNS text + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT entry ->> 's' +$$; + +------------------------------------------------------------------------------ +-- Equality-term extractor (XOR-aware: coalesce(hm, oc)) +------------------------------------------------------------------------------ + +--! @brief XOR-aware equality term extractor for eql_v3.jsonb_entry. +--! +--! Returns the bytea of whichever deterministic term the sv entry carries — +--! `hm` (HMAC-256) or `oc` (CLLW ORE). 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 eql_v3.jsonb_entry +--! @return bytea Decoded `hm` or `oc` bytes (NULL if entry is NULL). +CREATE FUNCTION eql_v3.eq_term(entry eql_v3.jsonb_entry) + RETURNS bytea + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT decode(coalesce(entry ->> 'hm', entry ->> 'oc'), 'hex') +$$; + +------------------------------------------------------------------------------ +-- ORE CLLW per-entry overloads (live here so sem/ore_cllw stays a leaf) +------------------------------------------------------------------------------ + +--! @brief Extract CLLW ORE index term from a ste_vec entry. +--! +--! `oc` is only ever present on an sv element, never at a root encrypted value, +--! so the typed overload accepts eql_v3.jsonb_entry. Returns SQL NULL when +--! `oc` is absent (btree NULL-filters such rows from range queries). +--! +--! @param entry eql_v3.jsonb_entry +--! @return eql_v3_internal.ore_cllw Composite carrying the CLLW ciphertext, or NULL. +--! @see eql_v3.has_ore_cllw +CREATE FUNCTION eql_v3.ore_cllw(entry eql_v3.jsonb_entry) + RETURNS eql_v3_internal.ore_cllw + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT CASE WHEN entry ->> 'oc' IS NULL THEN NULL + ELSE ROW(decode(entry ->> 'oc', 'hex'))::eql_v3_internal.ore_cllw + END +$$; + +--! @brief Check if a ste_vec entry contains a CLLW ORE index term. +--! @param entry eql_v3.jsonb_entry +--! @return boolean True if `oc` is present and non-null. +CREATE FUNCTION eql_v3.has_ore_cllw(entry eql_v3.jsonb_entry) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT entry ->> 'oc' IS NOT NULL +$$; + +------------------------------------------------------------------------------ +-- sv-array helpers +------------------------------------------------------------------------------ + +--! @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; + + SELECT array_agg(elem) + INTO ary + FROM jsonb_array_elements(sv) AS elem; + + RETURN ary; + END; +$$ LANGUAGE plpgsql; + +--! @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; + +------------------------------------------------------------------------------ +-- Deterministic-fields array for GIN containment +------------------------------------------------------------------------------ + +--! @brief Extract deterministic search fields (s, hm, oc, 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', 'oc', 'op') + GROUP BY elem + ); +$$; + +COMMENT ON FUNCTION eql_v3.jsonb_array(jsonb) IS + 'eql-inline-critical: raw-jsonb deterministic-field array helper; must stay inlinable (unpinned search_path)'; + +------------------------------------------------------------------------------ +-- Containment +------------------------------------------------------------------------------ + +--! @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 +--! `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 +AS $$ + SELECT eql_v3.jsonb_array(a) @> eql_v3.jsonb_array(b); +$$; + +COMMENT ON FUNCTION eql_v3.jsonb_contains(jsonb, jsonb) IS + 'eql-inline-critical: raw-jsonb containment helper; must stay inlinable (unpinned search_path)'; + +--! @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 +--! `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 +AS $$ + SELECT eql_v3.jsonb_array(a) <@ eql_v3.jsonb_array(b); +$$; + +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 Check if an sv array contains a specific sv element. +--! +--! Match = selector equal AND eq_term equal (byte-equality over coalesce(hm, +--! oc)). 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 oc 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; and an oc value carries a leading domain-tag byte an hm never +--! has. Unlike v2's explicit `has_hmac(both)`/`has_ore_cllw(both)`/`ELSE false` +--! CASE, this collapse would wrongly match an hm needle against an oc leaf if +--! their hex bytes were ever identical — which the contract prevents. 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; + + 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::eql_v3.jsonb_entry) = eql_v3.eq_term(b::eql_v3.jsonb_entry) + ); + EXIT WHEN result; + END LOOP; + + RETURN result; + END; +$$ LANGUAGE plpgsql; + +--! @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 eql_v3.json Container. +--! @param b 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 eql_v3.json, b 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); + + IF array_length(sv_b, 1) IS NULL THEN + RETURN true; + END IF; + + IF array_length(sv_a, 1) IS NULL THEN + RETURN false; + END IF; + + result := true; + + 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; + + RETURN result; + END; +$$ LANGUAGE plpgsql; + +------------------------------------------------------------------------------ +-- Path queries (text selector only) +------------------------------------------------------------------------------ + +--! @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 +--! eql_v3.json document, because the root document domain requires an `sv` +--! array and single leaves belong to eql_v3.jsonb_entry. +--! +--! @param val jsonb encrypted EQL payload with `sv`. +--! @param selector text Selector hash (`s` value). +--! @return SETOF 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 eql_v3.jsonb_entry + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT (eql_v3.meta_data(val) || elem)::eql_v3.jsonb_entry + FROM jsonb_array_elements(val -> 'sv') elem + WHERE elem ->> 's' = selector +$$; + +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)'; + +--! @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 + ); +$$; + +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)'; + +--! @brief Get the first sv element matching `selector`, or NULL. +--! @param val jsonb encrypted EQL payload. +--! @param selector text Selector hash to match. +--! @return eql_v3.jsonb_entry First matching element or NULL. +CREATE FUNCTION eql_v3.jsonb_path_query_first(val jsonb, selector text) + RETURNS eql_v3.jsonb_entry + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT (eql_v3.meta_data(val) || elem)::eql_v3.jsonb_entry + FROM jsonb_array_elements(val -> 'sv') elem + WHERE elem ->> 's' = selector + LIMIT 1 +$$; + +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)'; + +------------------------------------------------------------------------------ +-- Array functions +------------------------------------------------------------------------------ + +--! @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; + + RAISE 'cannot get array length of a non-array'; + END; +$$ 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 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 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; + + meta := eql_v3.meta_data(val); + sv := eql_v3.ste_vec(val); + + FOR idx IN 1..array_length(sv, 1) LOOP + item = sv[idx]; + RETURN NEXT (meta || item)::eql_v3.jsonb_entry; + END LOOP; + + RETURN; + END; +$$ LANGUAGE plpgsql; + +--! @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; + + sv := eql_v3.ste_vec(val); + + FOR idx IN 1..array_length(sv, 1) LOOP + RETURN NEXT eql_v3.ciphertext(sv[idx]); + END LOOP; + + RETURN; + END; +$$ LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE +-- Source is src/v3/version.template + +DROP FUNCTION IF EXISTS eql_v3.version(); + +--! @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-alpha.2 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. + +--! @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 +--! -- Check installed EQL version +--! SELECT eql_v3.version(); +--! -- Returns: '3.0.0' +CREATE FUNCTION eql_v3.version() + RETURNS text + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT '3.0.0-alpha.2'; +$$ 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-alpha.2'; + +--! @file v3/sem/ore_cllw/operator_class.sql +--! @brief Btree operator class on the eql_v3_internal.ore_cllw composite type. +--! +--! DEFAULT FOR TYPE so a functional btree index on eql_v3_internal.ore_cllw(expr) +--! engages without an explicit opclass annotation. FUNCTION 1 is the three-way +--! comparator btree's internal sort uses; it is plpgsql by design (per-byte +--! CLLW protocol needs iteration) and is called once per index-entry pair +--! during build / search, not per-row in the outer query. +--! +--! @note Excluded from the Supabase build variant by the build glob +--! `**/*operator_class.sql`. +--! @see eql_v3_internal.compare_ore_cllw_term + +CREATE OPERATOR FAMILY eql_v3_internal.ore_cllw_ops USING btree; + +CREATE OPERATOR CLASS eql_v3_internal.ore_cllw_ops + DEFAULT FOR TYPE eql_v3_internal.ore_cllw + USING btree FAMILY eql_v3_internal.ore_cllw_ops AS + OPERATOR 1 public.< (eql_v3_internal.ore_cllw, eql_v3_internal.ore_cllw), + OPERATOR 2 public.<= (eql_v3_internal.ore_cllw, eql_v3_internal.ore_cllw), + OPERATOR 3 public.= (eql_v3_internal.ore_cllw, eql_v3_internal.ore_cllw), + OPERATOR 4 public.>= (eql_v3_internal.ore_cllw, eql_v3_internal.ore_cllw), + OPERATOR 5 public.> (eql_v3_internal.ore_cllw, eql_v3_internal.ore_cllw), + FUNCTION 1 eql_v3_internal.compare_ore_cllw_term(eql_v3_internal.ore_cllw, eql_v3_internal.ore_cllw); + +--! @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_internal.ord_term(col))` engages without +--! an explicit opclass annotation (design D4). Excluded from the Supabase build +--! variant by the `**/*operator_class.sql` glob. + +--! @brief B-tree operator family for ORE block types +CREATE OPERATOR FAMILY eql_v3_internal.ore_block_256_operator_family USING btree; + +--! @brief B-tree operator class for ORE block encrypted values +--! +--! Supports operators: <, <=, =, >=, >. Uses comparison function +--! compare_ore_block_256_terms. +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); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ore_aggregates.sql +--! @brief Aggregates for eql_v3.timestamp_ord_ore. + +--! @brief State function for min on eql_v3.timestamp_ord_ore. +--! @param state eql_v3.timestamp_ord_ore +--! @param value eql_v3.timestamp_ord_ore +--! @return eql_v3.timestamp_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.timestamp_ord_ore, value eql_v3.timestamp_ord_ore) +RETURNS 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; +$$; + +--! @brief min aggregate for eql_v3.timestamp_ord_ore. +--! @param input eql_v3.timestamp_ord_ore +--! @return eql_v3.timestamp_ord_ore +CREATE AGGREGATE eql_v3.min(eql_v3.timestamp_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.timestamp_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.timestamp_ord_ore. +--! @param state eql_v3.timestamp_ord_ore +--! @param value eql_v3.timestamp_ord_ore +--! @return eql_v3.timestamp_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.timestamp_ord_ore, value eql_v3.timestamp_ord_ore) +RETURNS 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; +$$; + +--! @brief max aggregate for eql_v3.timestamp_ord_ore. +--! @param input eql_v3.timestamp_ord_ore +--! @return eql_v3.timestamp_ord_ore +CREATE AGGREGATE eql_v3.max(eql_v3.timestamp_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.timestamp_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ope_aggregates.sql +--! @brief Aggregates for eql_v3.timestamp_ord_ope. + +--! @brief State function for min on eql_v3.timestamp_ord_ope. +--! @param state eql_v3.timestamp_ord_ope +--! @param value eql_v3.timestamp_ord_ope +--! @return eql_v3.timestamp_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.timestamp_ord_ope, value eql_v3.timestamp_ord_ope) +RETURNS 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; +$$; + +--! @brief min aggregate for eql_v3.timestamp_ord_ope. +--! @param input eql_v3.timestamp_ord_ope +--! @return eql_v3.timestamp_ord_ope +CREATE AGGREGATE eql_v3.min(eql_v3.timestamp_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.timestamp_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.timestamp_ord_ope. +--! @param state eql_v3.timestamp_ord_ope +--! @param value eql_v3.timestamp_ord_ope +--! @return eql_v3.timestamp_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.timestamp_ord_ope, value eql_v3.timestamp_ord_ope) +RETURNS 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; +$$; + +--! @brief max aggregate for eql_v3.timestamp_ord_ope. +--! @param input eql_v3.timestamp_ord_ope +--! @return eql_v3.timestamp_ord_ope +CREATE AGGREGATE eql_v3.max(eql_v3.timestamp_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.timestamp_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_aggregates.sql +--! @brief Aggregates for eql_v3.timestamp_ord. + +--! @brief State function for min on eql_v3.timestamp_ord. +--! @param state eql_v3.timestamp_ord +--! @param value eql_v3.timestamp_ord +--! @return eql_v3.timestamp_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.timestamp_ord, value eql_v3.timestamp_ord) +RETURNS eql_v3.timestamp_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 eql_v3.timestamp_ord. +--! @param input eql_v3.timestamp_ord +--! @return eql_v3.timestamp_ord +CREATE AGGREGATE eql_v3.min(eql_v3.timestamp_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.timestamp_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.timestamp_ord. +--! @param state eql_v3.timestamp_ord +--! @param value eql_v3.timestamp_ord +--! @return eql_v3.timestamp_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.timestamp_ord, value eql_v3.timestamp_ord) +RETURNS eql_v3.timestamp_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 eql_v3.timestamp_ord. +--! @param input eql_v3.timestamp_ord +--! @return eql_v3.timestamp_ord +CREATE AGGREGATE eql_v3.max(eql_v3.timestamp_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.timestamp_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_operators.sql +--! @brief Operators for eql_v3.timestamp. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.timestamp, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.timestamp, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.timestamp, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.timestamp, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.timestamp, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.timestamp, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.timestamp, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.timestamp, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.timestamp, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.timestamp, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.timestamp, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.timestamp, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_eq_operators.sql +--! @brief Operators for eql_v3.timestamp_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_search_aggregates.sql +--! @brief Aggregates for eql_v3.text_search. + +--! @brief State function for min on eql_v3.text_search. +--! @param state eql_v3.text_search +--! @param value eql_v3.text_search +--! @return eql_v3.text_search +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.text_search, value eql_v3.text_search) +RETURNS 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 min aggregate for eql_v3.text_search. +--! @param input eql_v3.text_search +--! @return eql_v3.text_search +CREATE AGGREGATE eql_v3.min(eql_v3.text_search) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.text_search, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.text_search. +--! @param state eql_v3.text_search +--! @param value eql_v3.text_search +--! @return eql_v3.text_search +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.text_search, value eql_v3.text_search) +RETURNS 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 max aggregate for eql_v3.text_search. +--! @param input eql_v3.text_search +--! @return eql_v3.text_search +CREATE AGGREGATE eql_v3.max(eql_v3.text_search) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.text_search, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ore_aggregates.sql +--! @brief Aggregates for eql_v3.text_ord_ore. + +--! @brief State function for min on eql_v3.text_ord_ore. +--! @param state eql_v3.text_ord_ore +--! @param value eql_v3.text_ord_ore +--! @return eql_v3.text_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.text_ord_ore, value eql_v3.text_ord_ore) +RETURNS 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 eql_v3.text_ord_ore. +--! @param input eql_v3.text_ord_ore +--! @return eql_v3.text_ord_ore +CREATE AGGREGATE eql_v3.min(eql_v3.text_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.text_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.text_ord_ore. +--! @param state eql_v3.text_ord_ore +--! @param value eql_v3.text_ord_ore +--! @return eql_v3.text_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.text_ord_ore, value eql_v3.text_ord_ore) +RETURNS 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 eql_v3.text_ord_ore. +--! @param input eql_v3.text_ord_ore +--! @return eql_v3.text_ord_ore +CREATE AGGREGATE eql_v3.max(eql_v3.text_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.text_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ope_aggregates.sql +--! @brief Aggregates for eql_v3.text_ord_ope. + +--! @brief State function for min on eql_v3.text_ord_ope. +--! @param state eql_v3.text_ord_ope +--! @param value eql_v3.text_ord_ope +--! @return eql_v3.text_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.text_ord_ope, value eql_v3.text_ord_ope) +RETURNS eql_v3.text_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 eql_v3.text_ord_ope. +--! @param input eql_v3.text_ord_ope +--! @return eql_v3.text_ord_ope +CREATE AGGREGATE eql_v3.min(eql_v3.text_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.text_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.text_ord_ope. +--! @param state eql_v3.text_ord_ope +--! @param value eql_v3.text_ord_ope +--! @return eql_v3.text_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.text_ord_ope, value eql_v3.text_ord_ope) +RETURNS eql_v3.text_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 eql_v3.text_ord_ope. +--! @param input eql_v3.text_ord_ope +--! @return eql_v3.text_ord_ope +CREATE AGGREGATE eql_v3.max(eql_v3.text_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.text_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_aggregates.sql +--! @brief Aggregates for eql_v3.text_ord. + +--! @brief State function for min on eql_v3.text_ord. +--! @param state eql_v3.text_ord +--! @param value eql_v3.text_ord +--! @return eql_v3.text_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.text_ord, value eql_v3.text_ord) +RETURNS 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 eql_v3.text_ord. +--! @param input eql_v3.text_ord +--! @return eql_v3.text_ord +CREATE AGGREGATE eql_v3.min(eql_v3.text_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.text_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.text_ord. +--! @param state eql_v3.text_ord +--! @param value eql_v3.text_ord +--! @return eql_v3.text_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.text_ord, value eql_v3.text_ord) +RETURNS 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 eql_v3.text_ord. +--! @param input eql_v3.text_ord +--! @return eql_v3.text_ord +CREATE AGGREGATE eql_v3.max(eql_v3.text_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.text_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_operators.sql +--! @brief Operators for eql_v3.text. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.text, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.text, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.text, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.text, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.text, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.text, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.text, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.text, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.text, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.text, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.text, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.text, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.text, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.text, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.text, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.text, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_match_operators.sql +--! @brief Operators for eql_v3.text_match. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.text_match, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.text_match, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.text_match, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.text_match, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.text_match, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.text_match, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.text_match, RIGHTARG = jsonb, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_match, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.text_match, RIGHTARG = jsonb, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_match, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text_match, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text_match, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text_match, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text_match, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.text_match, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.text_match, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.text_match, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.text_match, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.text_match, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.text_match, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.text_match, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_match, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_match, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_match, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.text_match, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text_match, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_match +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_eq_operators.sql +--! @brief Operators for eql_v3.text_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.text_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ore_aggregates.sql +--! @brief Aggregates for eql_v3.smallint_ord_ore. + +--! @brief State function for min on eql_v3.smallint_ord_ore. +--! @param state eql_v3.smallint_ord_ore +--! @param value eql_v3.smallint_ord_ore +--! @return eql_v3.smallint_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.smallint_ord_ore, value eql_v3.smallint_ord_ore) +RETURNS 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 eql_v3.smallint_ord_ore. +--! @param input eql_v3.smallint_ord_ore +--! @return eql_v3.smallint_ord_ore +CREATE AGGREGATE eql_v3.min(eql_v3.smallint_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.smallint_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.smallint_ord_ore. +--! @param state eql_v3.smallint_ord_ore +--! @param value eql_v3.smallint_ord_ore +--! @return eql_v3.smallint_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.smallint_ord_ore, value eql_v3.smallint_ord_ore) +RETURNS 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 eql_v3.smallint_ord_ore. +--! @param input eql_v3.smallint_ord_ore +--! @return eql_v3.smallint_ord_ore +CREATE AGGREGATE eql_v3.max(eql_v3.smallint_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = 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 eql_v3.smallint_ord_ope. + +--! @brief State function for min on eql_v3.smallint_ord_ope. +--! @param state eql_v3.smallint_ord_ope +--! @param value eql_v3.smallint_ord_ope +--! @return eql_v3.smallint_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.smallint_ord_ope, value eql_v3.smallint_ord_ope) +RETURNS 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 min aggregate for eql_v3.smallint_ord_ope. +--! @param input eql_v3.smallint_ord_ope +--! @return eql_v3.smallint_ord_ope +CREATE AGGREGATE eql_v3.min(eql_v3.smallint_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.smallint_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.smallint_ord_ope. +--! @param state eql_v3.smallint_ord_ope +--! @param value eql_v3.smallint_ord_ope +--! @return eql_v3.smallint_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.smallint_ord_ope, value eql_v3.smallint_ord_ope) +RETURNS 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 max aggregate for eql_v3.smallint_ord_ope. +--! @param input eql_v3.smallint_ord_ope +--! @return eql_v3.smallint_ord_ope +CREATE AGGREGATE eql_v3.max(eql_v3.smallint_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.smallint_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_aggregates.sql +--! @brief Aggregates for eql_v3.smallint_ord. + +--! @brief State function for min on eql_v3.smallint_ord. +--! @param state eql_v3.smallint_ord +--! @param value eql_v3.smallint_ord +--! @return eql_v3.smallint_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.smallint_ord, value eql_v3.smallint_ord) +RETURNS 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 min aggregate for eql_v3.smallint_ord. +--! @param input eql_v3.smallint_ord +--! @return eql_v3.smallint_ord +CREATE AGGREGATE eql_v3.min(eql_v3.smallint_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.smallint_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.smallint_ord. +--! @param state eql_v3.smallint_ord +--! @param value eql_v3.smallint_ord +--! @return eql_v3.smallint_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.smallint_ord, value eql_v3.smallint_ord) +RETURNS 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 max aggregate for eql_v3.smallint_ord. +--! @param input eql_v3.smallint_ord +--! @return eql_v3.smallint_ord +CREATE AGGREGATE eql_v3.max(eql_v3.smallint_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.smallint_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_operators.sql +--! @brief Operators for eql_v3.smallint. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.smallint, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.smallint, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.smallint, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.smallint, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.smallint, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.smallint, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.smallint, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.smallint, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.smallint, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.smallint, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.smallint, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.smallint, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_eq_operators.sql +--! @brief Operators for eql_v3.smallint_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ore_aggregates.sql +--! @brief Aggregates for eql_v3.real_ord_ore. + +--! @brief State function for min on eql_v3.real_ord_ore. +--! @param state eql_v3.real_ord_ore +--! @param value eql_v3.real_ord_ore +--! @return eql_v3.real_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.real_ord_ore, value eql_v3.real_ord_ore) +RETURNS 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 min aggregate for eql_v3.real_ord_ore. +--! @param input eql_v3.real_ord_ore +--! @return eql_v3.real_ord_ore +CREATE AGGREGATE eql_v3.min(eql_v3.real_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.real_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.real_ord_ore. +--! @param state eql_v3.real_ord_ore +--! @param value eql_v3.real_ord_ore +--! @return eql_v3.real_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.real_ord_ore, value eql_v3.real_ord_ore) +RETURNS 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 max aggregate for eql_v3.real_ord_ore. +--! @param input eql_v3.real_ord_ore +--! @return eql_v3.real_ord_ore +CREATE AGGREGATE eql_v3.max(eql_v3.real_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.real_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ope_aggregates.sql +--! @brief Aggregates for eql_v3.real_ord_ope. + +--! @brief State function for min on eql_v3.real_ord_ope. +--! @param state eql_v3.real_ord_ope +--! @param value eql_v3.real_ord_ope +--! @return eql_v3.real_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.real_ord_ope, value eql_v3.real_ord_ope) +RETURNS 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 min aggregate for eql_v3.real_ord_ope. +--! @param input eql_v3.real_ord_ope +--! @return eql_v3.real_ord_ope +CREATE AGGREGATE eql_v3.min(eql_v3.real_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.real_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.real_ord_ope. +--! @param state eql_v3.real_ord_ope +--! @param value eql_v3.real_ord_ope +--! @return eql_v3.real_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.real_ord_ope, value eql_v3.real_ord_ope) +RETURNS 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 max aggregate for eql_v3.real_ord_ope. +--! @param input eql_v3.real_ord_ope +--! @return eql_v3.real_ord_ope +CREATE AGGREGATE eql_v3.max(eql_v3.real_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.real_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_aggregates.sql +--! @brief Aggregates for eql_v3.real_ord. + +--! @brief State function for min on eql_v3.real_ord. +--! @param state eql_v3.real_ord +--! @param value eql_v3.real_ord +--! @return eql_v3.real_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.real_ord, value eql_v3.real_ord) +RETURNS 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 min aggregate for eql_v3.real_ord. +--! @param input eql_v3.real_ord +--! @return eql_v3.real_ord +CREATE AGGREGATE eql_v3.min(eql_v3.real_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.real_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.real_ord. +--! @param state eql_v3.real_ord +--! @param value eql_v3.real_ord +--! @return eql_v3.real_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.real_ord, value eql_v3.real_ord) +RETURNS 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 max aggregate for eql_v3.real_ord. +--! @param input eql_v3.real_ord +--! @return eql_v3.real_ord +CREATE AGGREGATE eql_v3.max(eql_v3.real_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.real_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_operators.sql +--! @brief Operators for eql_v3.real. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.real, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.real, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.real, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.real, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.real, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.real, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.real, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.real, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.real, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.real, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.real, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.real, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.real, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.real, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.real, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.real, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.real, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.real, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.real, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.real, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.real, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.real +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_eq_operators.sql +--! @brief Operators for eql_v3.real_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.real_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.real_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.real_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.real_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.real_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.real_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.real_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.real_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.real_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.real_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.real_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.real_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ore_aggregates.sql +--! @brief Aggregates for eql_v3.numeric_ord_ore. + +--! @brief State function for min on eql_v3.numeric_ord_ore. +--! @param state eql_v3.numeric_ord_ore +--! @param value eql_v3.numeric_ord_ore +--! @return eql_v3.numeric_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.numeric_ord_ore, value eql_v3.numeric_ord_ore) +RETURNS 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 eql_v3.numeric_ord_ore. +--! @param input eql_v3.numeric_ord_ore +--! @return eql_v3.numeric_ord_ore +CREATE AGGREGATE eql_v3.min(eql_v3.numeric_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.numeric_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.numeric_ord_ore. +--! @param state eql_v3.numeric_ord_ore +--! @param value eql_v3.numeric_ord_ore +--! @return eql_v3.numeric_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.numeric_ord_ore, value eql_v3.numeric_ord_ore) +RETURNS 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 eql_v3.numeric_ord_ore. +--! @param input eql_v3.numeric_ord_ore +--! @return eql_v3.numeric_ord_ore +CREATE AGGREGATE eql_v3.max(eql_v3.numeric_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = 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 eql_v3.numeric_ord_ope. + +--! @brief State function for min on eql_v3.numeric_ord_ope. +--! @param state eql_v3.numeric_ord_ope +--! @param value eql_v3.numeric_ord_ope +--! @return eql_v3.numeric_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.numeric_ord_ope, value eql_v3.numeric_ord_ope) +RETURNS 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 eql_v3.numeric_ord_ope. +--! @param input eql_v3.numeric_ord_ope +--! @return eql_v3.numeric_ord_ope +CREATE AGGREGATE eql_v3.min(eql_v3.numeric_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.numeric_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.numeric_ord_ope. +--! @param state eql_v3.numeric_ord_ope +--! @param value eql_v3.numeric_ord_ope +--! @return eql_v3.numeric_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.numeric_ord_ope, value eql_v3.numeric_ord_ope) +RETURNS 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 eql_v3.numeric_ord_ope. +--! @param input eql_v3.numeric_ord_ope +--! @return eql_v3.numeric_ord_ope +CREATE AGGREGATE eql_v3.max(eql_v3.numeric_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.numeric_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_aggregates.sql +--! @brief Aggregates for eql_v3.numeric_ord. + +--! @brief State function for min on eql_v3.numeric_ord. +--! @param state eql_v3.numeric_ord +--! @param value eql_v3.numeric_ord +--! @return eql_v3.numeric_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.numeric_ord, value eql_v3.numeric_ord) +RETURNS 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 min aggregate for eql_v3.numeric_ord. +--! @param input eql_v3.numeric_ord +--! @return eql_v3.numeric_ord +CREATE AGGREGATE eql_v3.min(eql_v3.numeric_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.numeric_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.numeric_ord. +--! @param state eql_v3.numeric_ord +--! @param value eql_v3.numeric_ord +--! @return eql_v3.numeric_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.numeric_ord, value eql_v3.numeric_ord) +RETURNS 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 max aggregate for eql_v3.numeric_ord. +--! @param input eql_v3.numeric_ord +--! @return eql_v3.numeric_ord +CREATE AGGREGATE eql_v3.max(eql_v3.numeric_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.numeric_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_operators.sql +--! @brief Operators for eql_v3.numeric. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.numeric, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.numeric, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.numeric, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.numeric, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.numeric, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.numeric, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.numeric, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_eq_operators.sql +--! @brief Operators for eql_v3.numeric_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ore_aggregates.sql +--! @brief Aggregates for eql_v3.integer_ord_ore. + +--! @brief State function for min on eql_v3.integer_ord_ore. +--! @param state eql_v3.integer_ord_ore +--! @param value eql_v3.integer_ord_ore +--! @return eql_v3.integer_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.integer_ord_ore, value eql_v3.integer_ord_ore) +RETURNS 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 min aggregate for eql_v3.integer_ord_ore. +--! @param input eql_v3.integer_ord_ore +--! @return eql_v3.integer_ord_ore +CREATE AGGREGATE eql_v3.min(eql_v3.integer_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.integer_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.integer_ord_ore. +--! @param state eql_v3.integer_ord_ore +--! @param value eql_v3.integer_ord_ore +--! @return eql_v3.integer_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.integer_ord_ore, value eql_v3.integer_ord_ore) +RETURNS 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 max aggregate for eql_v3.integer_ord_ore. +--! @param input eql_v3.integer_ord_ore +--! @return eql_v3.integer_ord_ore +CREATE AGGREGATE eql_v3.max(eql_v3.integer_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.integer_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ope_aggregates.sql +--! @brief Aggregates for eql_v3.integer_ord_ope. + +--! @brief State function for min on eql_v3.integer_ord_ope. +--! @param state eql_v3.integer_ord_ope +--! @param value eql_v3.integer_ord_ope +--! @return eql_v3.integer_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.integer_ord_ope, value eql_v3.integer_ord_ope) +RETURNS 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 min aggregate for eql_v3.integer_ord_ope. +--! @param input eql_v3.integer_ord_ope +--! @return eql_v3.integer_ord_ope +CREATE AGGREGATE eql_v3.min(eql_v3.integer_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.integer_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.integer_ord_ope. +--! @param state eql_v3.integer_ord_ope +--! @param value eql_v3.integer_ord_ope +--! @return eql_v3.integer_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.integer_ord_ope, value eql_v3.integer_ord_ope) +RETURNS 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 max aggregate for eql_v3.integer_ord_ope. +--! @param input eql_v3.integer_ord_ope +--! @return eql_v3.integer_ord_ope +CREATE AGGREGATE eql_v3.max(eql_v3.integer_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.integer_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_aggregates.sql +--! @brief Aggregates for eql_v3.integer_ord. + +--! @brief State function for min on eql_v3.integer_ord. +--! @param state eql_v3.integer_ord +--! @param value eql_v3.integer_ord +--! @return eql_v3.integer_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.integer_ord, value eql_v3.integer_ord) +RETURNS 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 min aggregate for eql_v3.integer_ord. +--! @param input eql_v3.integer_ord +--! @return eql_v3.integer_ord +CREATE AGGREGATE eql_v3.min(eql_v3.integer_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.integer_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.integer_ord. +--! @param state eql_v3.integer_ord +--! @param value eql_v3.integer_ord +--! @return eql_v3.integer_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.integer_ord, value eql_v3.integer_ord) +RETURNS 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 max aggregate for eql_v3.integer_ord. +--! @param input eql_v3.integer_ord +--! @return eql_v3.integer_ord +CREATE AGGREGATE eql_v3.max(eql_v3.integer_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.integer_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_operators.sql +--! @brief Operators for eql_v3.integer. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.integer, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.integer, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.integer, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.integer, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.integer, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.integer, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.integer, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.integer, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.integer, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.integer, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.integer, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.integer, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_eq_operators.sql +--! @brief Operators for eql_v3.integer_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.integer_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.integer_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.integer_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.integer_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.integer_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ore_aggregates.sql +--! @brief Aggregates for eql_v3.double_ord_ore. + +--! @brief State function for min on eql_v3.double_ord_ore. +--! @param state eql_v3.double_ord_ore +--! @param value eql_v3.double_ord_ore +--! @return eql_v3.double_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.double_ord_ore, value eql_v3.double_ord_ore) +RETURNS 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; +$$; + +--! @brief min aggregate for eql_v3.double_ord_ore. +--! @param input eql_v3.double_ord_ore +--! @return eql_v3.double_ord_ore +CREATE AGGREGATE eql_v3.min(eql_v3.double_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.double_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.double_ord_ore. +--! @param state eql_v3.double_ord_ore +--! @param value eql_v3.double_ord_ore +--! @return eql_v3.double_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.double_ord_ore, value eql_v3.double_ord_ore) +RETURNS 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; +$$; + +--! @brief max aggregate for eql_v3.double_ord_ore. +--! @param input eql_v3.double_ord_ore +--! @return eql_v3.double_ord_ore +CREATE AGGREGATE eql_v3.max(eql_v3.double_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.double_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ope_aggregates.sql +--! @brief Aggregates for eql_v3.double_ord_ope. + +--! @brief State function for min on eql_v3.double_ord_ope. +--! @param state eql_v3.double_ord_ope +--! @param value eql_v3.double_ord_ope +--! @return eql_v3.double_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.double_ord_ope, value eql_v3.double_ord_ope) +RETURNS eql_v3.double_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 eql_v3.double_ord_ope. +--! @param input eql_v3.double_ord_ope +--! @return eql_v3.double_ord_ope +CREATE AGGREGATE eql_v3.min(eql_v3.double_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.double_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.double_ord_ope. +--! @param state eql_v3.double_ord_ope +--! @param value eql_v3.double_ord_ope +--! @return eql_v3.double_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.double_ord_ope, value eql_v3.double_ord_ope) +RETURNS eql_v3.double_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 eql_v3.double_ord_ope. +--! @param input eql_v3.double_ord_ope +--! @return eql_v3.double_ord_ope +CREATE AGGREGATE eql_v3.max(eql_v3.double_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.double_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_aggregates.sql +--! @brief Aggregates for eql_v3.double_ord. + +--! @brief State function for min on eql_v3.double_ord. +--! @param state eql_v3.double_ord +--! @param value eql_v3.double_ord +--! @return eql_v3.double_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.double_ord, value eql_v3.double_ord) +RETURNS 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 min aggregate for eql_v3.double_ord. +--! @param input eql_v3.double_ord +--! @return eql_v3.double_ord +CREATE AGGREGATE eql_v3.min(eql_v3.double_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.double_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.double_ord. +--! @param state eql_v3.double_ord +--! @param value eql_v3.double_ord +--! @return eql_v3.double_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.double_ord, value eql_v3.double_ord) +RETURNS 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 eql_v3.double_ord. +--! @param input eql_v3.double_ord +--! @return eql_v3.double_ord +CREATE AGGREGATE eql_v3.max(eql_v3.double_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.double_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_operators.sql +--! @brief Operators for eql_v3.double. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.double, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.double, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.double, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.double, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.double, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.double, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.double, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.double, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.double, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.double, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.double, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.double, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.double, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.double, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.double, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.double, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.double, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.double, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.double, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.double, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.double, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.double +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_eq_operators.sql +--! @brief Operators for eql_v3.double_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.double_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.double_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.double_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.double_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.double_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.double_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.double_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ore_aggregates.sql +--! @brief Aggregates for eql_v3.date_ord_ore. + +--! @brief State function for min on eql_v3.date_ord_ore. +--! @param state eql_v3.date_ord_ore +--! @param value eql_v3.date_ord_ore +--! @return eql_v3.date_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.date_ord_ore, value eql_v3.date_ord_ore) +RETURNS 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 min aggregate for eql_v3.date_ord_ore. +--! @param input eql_v3.date_ord_ore +--! @return eql_v3.date_ord_ore +CREATE AGGREGATE eql_v3.min(eql_v3.date_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.date_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.date_ord_ore. +--! @param state eql_v3.date_ord_ore +--! @param value eql_v3.date_ord_ore +--! @return eql_v3.date_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.date_ord_ore, value eql_v3.date_ord_ore) +RETURNS 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 max aggregate for eql_v3.date_ord_ore. +--! @param input eql_v3.date_ord_ore +--! @return eql_v3.date_ord_ore +CREATE AGGREGATE eql_v3.max(eql_v3.date_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.date_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ope_aggregates.sql +--! @brief Aggregates for eql_v3.date_ord_ope. + +--! @brief State function for min on eql_v3.date_ord_ope. +--! @param state eql_v3.date_ord_ope +--! @param value eql_v3.date_ord_ope +--! @return eql_v3.date_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.date_ord_ope, value eql_v3.date_ord_ope) +RETURNS 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 min aggregate for eql_v3.date_ord_ope. +--! @param input eql_v3.date_ord_ope +--! @return eql_v3.date_ord_ope +CREATE AGGREGATE eql_v3.min(eql_v3.date_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.date_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.date_ord_ope. +--! @param state eql_v3.date_ord_ope +--! @param value eql_v3.date_ord_ope +--! @return eql_v3.date_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.date_ord_ope, value eql_v3.date_ord_ope) +RETURNS 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 max aggregate for eql_v3.date_ord_ope. +--! @param input eql_v3.date_ord_ope +--! @return eql_v3.date_ord_ope +CREATE AGGREGATE eql_v3.max(eql_v3.date_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.date_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_aggregates.sql +--! @brief Aggregates for eql_v3.date_ord. + +--! @brief State function for min on eql_v3.date_ord. +--! @param state eql_v3.date_ord +--! @param value eql_v3.date_ord +--! @return eql_v3.date_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.date_ord, value eql_v3.date_ord) +RETURNS 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 min aggregate for eql_v3.date_ord. +--! @param input eql_v3.date_ord +--! @return eql_v3.date_ord +CREATE AGGREGATE eql_v3.min(eql_v3.date_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.date_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.date_ord. +--! @param state eql_v3.date_ord +--! @param value eql_v3.date_ord +--! @return eql_v3.date_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.date_ord, value eql_v3.date_ord) +RETURNS 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 max aggregate for eql_v3.date_ord. +--! @param input eql_v3.date_ord +--! @return eql_v3.date_ord +CREATE AGGREGATE eql_v3.max(eql_v3.date_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.date_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_operators.sql +--! @brief Operators for eql_v3.date. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.date, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.date, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.date, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.date, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.date, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.date, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.date, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.date, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.date, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.date, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.date, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.date, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.date, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.date, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.date, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.date, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.date, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.date, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.date, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.date, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.date, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_eq_operators.sql +--! @brief Operators for eql_v3.date_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.date_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.date_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.date_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.date_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.date_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/boolean/boolean_operators.sql +--! @brief Operators for eql_v3.boolean. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.boolean, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.boolean, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.boolean, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.boolean, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.boolean, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.boolean, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.boolean, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.boolean, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.boolean, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.boolean, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.boolean, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.boolean, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.boolean, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.boolean, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.boolean, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.boolean +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ore_aggregates.sql +--! @brief Aggregates for eql_v3.bigint_ord_ore. + +--! @brief State function for min on eql_v3.bigint_ord_ore. +--! @param state eql_v3.bigint_ord_ore +--! @param value eql_v3.bigint_ord_ore +--! @return eql_v3.bigint_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.bigint_ord_ore, value eql_v3.bigint_ord_ore) +RETURNS 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 eql_v3.bigint_ord_ore. +--! @param input eql_v3.bigint_ord_ore +--! @return eql_v3.bigint_ord_ore +CREATE AGGREGATE eql_v3.min(eql_v3.bigint_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.bigint_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.bigint_ord_ore. +--! @param state eql_v3.bigint_ord_ore +--! @param value eql_v3.bigint_ord_ore +--! @return eql_v3.bigint_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.bigint_ord_ore, value eql_v3.bigint_ord_ore) +RETURNS 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 eql_v3.bigint_ord_ore. +--! @param input eql_v3.bigint_ord_ore +--! @return eql_v3.bigint_ord_ore +CREATE AGGREGATE eql_v3.max(eql_v3.bigint_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = 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 eql_v3.bigint_ord_ope. + +--! @brief State function for min on eql_v3.bigint_ord_ope. +--! @param state eql_v3.bigint_ord_ope +--! @param value eql_v3.bigint_ord_ope +--! @return eql_v3.bigint_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.bigint_ord_ope, value eql_v3.bigint_ord_ope) +RETURNS 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 eql_v3.bigint_ord_ope. +--! @param input eql_v3.bigint_ord_ope +--! @return eql_v3.bigint_ord_ope +CREATE AGGREGATE eql_v3.min(eql_v3.bigint_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.bigint_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.bigint_ord_ope. +--! @param state eql_v3.bigint_ord_ope +--! @param value eql_v3.bigint_ord_ope +--! @return eql_v3.bigint_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.bigint_ord_ope, value eql_v3.bigint_ord_ope) +RETURNS 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 eql_v3.bigint_ord_ope. +--! @param input eql_v3.bigint_ord_ope +--! @return eql_v3.bigint_ord_ope +CREATE AGGREGATE eql_v3.max(eql_v3.bigint_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = 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 eql_v3.bigint_ord. + +--! @brief State function for min on eql_v3.bigint_ord. +--! @param state eql_v3.bigint_ord +--! @param value eql_v3.bigint_ord +--! @return eql_v3.bigint_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.bigint_ord, value eql_v3.bigint_ord) +RETURNS 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 min aggregate for eql_v3.bigint_ord. +--! @param input eql_v3.bigint_ord +--! @return eql_v3.bigint_ord +CREATE AGGREGATE eql_v3.min(eql_v3.bigint_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.bigint_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.bigint_ord. +--! @param state eql_v3.bigint_ord +--! @param value eql_v3.bigint_ord +--! @return eql_v3.bigint_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.bigint_ord, value eql_v3.bigint_ord) +RETURNS 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 max aggregate for eql_v3.bigint_ord. +--! @param input eql_v3.bigint_ord +--! @return eql_v3.bigint_ord +CREATE AGGREGATE eql_v3.max(eql_v3.bigint_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.bigint_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_operators.sql +--! @brief Operators for eql_v3.bigint. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.bigint, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.bigint, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.bigint, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.bigint, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.bigint, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.bigint, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.bigint, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.bigint, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.bigint, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.bigint, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.bigint, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.bigint, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_eq_operators.sql +--! @brief Operators for eql_v3.bigint_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq +); + +--! @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 types `eql_v3_internal.ore_block_256`, `eql_v3_internal.ore_cllw`) 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 + -- All operators where at least one operand is an `eql_v3` type. 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())) + ) + ), + + -- 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 + ), + + -- 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 `eql_v3` 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 pg_catalog.pg_type dt ON dt.oid = arg.typ + JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace + JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype + WHERE dt.typtype = 'd' + AND bt.typname = 'jsonb' + AND dn.nspname = ANY(eql_v3_internal.owned_schemas()) + ) + ) + + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ 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). │ + -- └─────────────────────────────────────────────────────────────────┘ + + 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 + ) + + UNION ALL + + 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 + ) + + UNION ALL + + 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 + ) + + UNION ALL + + 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 + ) + + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ 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. │ + -- └─────────────────────────────────────────────────────────────────┘ + + UNION ALL + + 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 + ) + + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ 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. │ + -- └─────────────────────────────────────────────────────────────────┘ + + UNION ALL + + 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' + + UNION ALL + + 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 + + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ 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. │ + -- └─────────────────────────────────────────────────────────────────┘ + + UNION ALL + + 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 bn.nspname = ANY(eql_v3_internal.owned_schemas()) + + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ 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. │ + -- └─────────────────────────────────────────────────────────────────┘ + + UNION ALL + + 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.typtype = 'd' + AND tn.nspname = ANY(eql_v3_internal.owned_schemas()) + + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ 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. │ + -- └─────────────────────────────────────────────────────────────────┘ + + UNION ALL + + 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') + + ORDER BY 1, 2, 3; +$$; + +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.'; + +--! @file v3/jsonb/operators.sql +--! @brief Operators on eql_v3.json and eql_v3.jsonb_entry. + +------------------------------------------------------------------------------ +-- -> field accessor (returns jsonb_entry) +------------------------------------------------------------------------------ + +--! @brief -> operator with text selector. +--! +--! Returns the sv entry whose `s` equals @p selector, with root `i`/`v` merged +--! in. Inlinable: `WHERE col -> 'sel' = $1` reduces structurally to +--! `eql_v3.eq_term(col -> 'sel') = eql_v3.eq_term($1)` and matches a functional +--! index on `eql_v3.eq_term(col -> 'sel')`. +--! +--! @warning The selector operand MUST carry a known type — a text-typed +--! 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 `eql_v3.json` +--! 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 eql_v3.json Root encrypted payload. +--! @param selector text Selector hash. +--! @return eql_v3.jsonb_entry Matching entry merged with root meta, or NULL. +CREATE FUNCTION eql_v3."->"(e eql_v3.json, selector text) + RETURNS eql_v3.jsonb_entry + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT ( + eql_v3.meta_data(e) || + jsonb_path_query_first( + e, + '$.sv[*] ? (@.s == $sel)'::jsonpath, + jsonb_build_object('sel', selector) + ) + )::eql_v3.jsonb_entry +$$; + +CREATE OPERATOR ->( + FUNCTION=eql_v3."->", + LEFTARG=eql_v3.json, + RIGHTARG=text +); + +--! @brief -> operator with integer array index (0-based, JSONB convention). +--! @param e eql_v3.json Encrypted sv-array payload. +--! @param selector integer Array index. +--! @return eql_v3.jsonb_entry Matching entry merged with root meta, or NULL. +CREATE FUNCTION eql_v3."->"(e eql_v3.json, selector integer) + RETURNS eql_v3.jsonb_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 `eql_v3.json` to + -- its base type and binds native `jsonb -> text` (see the @warning above) — + -- the custom `->(eql_v3.json, 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 `->(eql_v3.json, integer)` + -- operator instead of native array access. + (eql_v3.meta_data(e) || (e::jsonb -> 'sv' -> selector))::eql_v3.jsonb_entry + ELSE NULL + END +$$; + +CREATE OPERATOR ->( + FUNCTION=eql_v3."->", + LEFTARG=eql_v3.json, + RIGHTARG=integer +); + +------------------------------------------------------------------------------ +-- ->> field accessor (alias of -> coerced to text) +------------------------------------------------------------------------------ + +--! @brief ->> operator with text selector. Inlinable alias of -> coerced to +--! text. +--! +--! 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 eql_v3.json Encrypted payload. +--! @param selector text Field selector hash. +--! @return text The matching entry as text. +CREATE FUNCTION eql_v3."->>"(e eql_v3.json, selector text) + RETURNS text + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3."->"(e, selector)::jsonb::text +$$; + +CREATE OPERATOR ->> ( + FUNCTION=eql_v3."->>", + LEFTARG=eql_v3.json, + RIGHTARG=text +); + +--! @brief ->> operator with integer array index. Inlinable alias of +--! ->(json, integer) coerced to text. +--! @param e eql_v3.json Encrypted sv-array payload. +--! @param selector integer Array index. +--! @return text The matching entry as text. +CREATE FUNCTION eql_v3."->>"(e eql_v3.json, selector integer) + RETURNS text + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3."->"(e, selector)::jsonb::text +$$; + +CREATE OPERATOR ->> ( + FUNCTION=eql_v3."->>", + LEFTARG=eql_v3.json, + RIGHTARG=integer +); + +------------------------------------------------------------------------------ +-- @> containment +------------------------------------------------------------------------------ + +--! @brief @> contains operator (document, document). +--! @param a eql_v3.json Container. +--! @param b eql_v3.json Contained value. +--! @return boolean True if a contains b. +--! @see eql_v3.ste_vec_contains +CREATE FUNCTION eql_v3."@>"(a eql_v3.json, b eql_v3.json) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ste_vec_contains(a, b) +$$; + +CREATE OPERATOR @>( + FUNCTION=eql_v3."@>", + LEFTARG=eql_v3.json, + RIGHTARG=eql_v3.json +); + +--! @brief @> contains operator with an jsonb_query 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 eql_v3.json Container. +--! @param b eql_v3.jsonb_query Query payload. +--! @return boolean True if a contains b. +CREATE FUNCTION eql_v3."@>"(a eql_v3.json, b eql_v3.jsonb_query) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.to_ste_vec_query(a)::jsonb @> b::jsonb +$$; + +CREATE OPERATOR @>( + FUNCTION=eql_v3."@>", + LEFTARG=eql_v3.json, + RIGHTARG=eql_v3.jsonb_query +); + +--! @brief @> contains operator with a single jsonb_entry needle. +--! +--! 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 eql_v3.json Container. +--! @param b eql_v3.jsonb_entry Single entry. +--! @return boolean True if a contains an sv entry matching b. +CREATE FUNCTION eql_v3."@>"(a eql_v3.json, b eql_v3.jsonb_entry) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.to_ste_vec_query(a)::jsonb + @> jsonb_build_object( + 'sv', + jsonb_build_array( + jsonb_strip_nulls( + jsonb_build_object( + 's', b -> 's', + 'hm', b -> 'hm', + 'oc', b -> 'oc' + ) + ) + ) + ) +$$; + +CREATE OPERATOR @>( + FUNCTION=eql_v3."@>", + LEFTARG=eql_v3.json, + RIGHTARG=eql_v3.jsonb_entry +); + +------------------------------------------------------------------------------ +-- <@ contained-by (reverse of @>) +------------------------------------------------------------------------------ + +--! @brief <@ contained-by operator (document, document). +--! @param a eql_v3.json Contained value. +--! @param b eql_v3.json Container. +--! @return boolean True if a is contained by b. +CREATE FUNCTION eql_v3."<@"(a eql_v3.json, b eql_v3.json) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ste_vec_contains(b, a) +$$; + +CREATE OPERATOR <@( + FUNCTION=eql_v3."<@", + LEFTARG=eql_v3.json, + RIGHTARG=eql_v3.json +); + +--! @brief <@ contained-by operator with an jsonb_query LHS. +--! @param a eql_v3.jsonb_query Query payload. +--! @param b eql_v3.json Container. +--! @return boolean True if b contains a. +CREATE FUNCTION eql_v3."<@"(a eql_v3.jsonb_query, b eql_v3.json) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3."@>"(b, a) +$$; + +CREATE OPERATOR <@( + FUNCTION=eql_v3."<@", + LEFTARG=eql_v3.jsonb_query, + RIGHTARG=eql_v3.json +); + +--! @brief <@ contained-by operator with a jsonb_entry LHS. +--! @param a eql_v3.jsonb_entry Single entry. +--! @param b eql_v3.json Container. +--! @return boolean True if b contains a. +CREATE FUNCTION eql_v3."<@"(a eql_v3.jsonb_entry, b eql_v3.json) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3."@>"(b, a) +$$; + +CREATE OPERATOR <@( + FUNCTION=eql_v3."<@", + LEFTARG=eql_v3.jsonb_entry, + RIGHTARG=eql_v3.json +); + +------------------------------------------------------------------------------ +-- jsonb_entry comparisons +------------------------------------------------------------------------------ + +--! @brief Equality on jsonb_entry via eq_term (hm-or-oc byte equality). +--! @param a eql_v3.jsonb_entry Left operand +--! @param b eql_v3.jsonb_entry Right operand +--! @return boolean True if the entries are equal +CREATE FUNCTION eql_v3.eq(a eql_v3.jsonb_entry, b eql_v3.jsonb_entry) + 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.jsonb_entry, + RIGHTARG = eql_v3.jsonb_entry, + COMMUTATOR = =, + NEGATOR = <>, + RESTRICT = eqsel, + JOIN = eqjoinsel +); + +--! @brief Inequality on jsonb_entry via eq_term. +--! @param a eql_v3.jsonb_entry Left operand +--! @param b eql_v3.jsonb_entry Right operand +--! @return boolean True if the entries are not equal +CREATE FUNCTION eql_v3.neq(a eql_v3.jsonb_entry, b eql_v3.jsonb_entry) + 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.jsonb_entry, + RIGHTARG = eql_v3.jsonb_entry, + COMMUTATOR = <>, + NEGATOR = =, + RESTRICT = neqsel, + JOIN = neqjoinsel +); + +--! @brief Less-than on jsonb_entry via ore_cllw. +--! @param a eql_v3.jsonb_entry Left operand +--! @param b eql_v3.jsonb_entry Right operand +--! @return boolean True if a is less than b +CREATE FUNCTION eql_v3.lt(a eql_v3.jsonb_entry, b eql_v3.jsonb_entry) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ore_cllw(a) < eql_v3.ore_cllw(b) +$$; + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.jsonb_entry, + RIGHTARG = eql_v3.jsonb_entry, + COMMUTATOR = >, + NEGATOR = >=, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel +); + +--! @brief Less-than-or-equal on jsonb_entry via ore_cllw. +--! @param a eql_v3.jsonb_entry Left operand +--! @param b eql_v3.jsonb_entry Right operand +--! @return boolean True if a is less than or equal to b +CREATE FUNCTION eql_v3.lte(a eql_v3.jsonb_entry, b eql_v3.jsonb_entry) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ore_cllw(a) <= eql_v3.ore_cllw(b) +$$; + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.jsonb_entry, + RIGHTARG = eql_v3.jsonb_entry, + COMMUTATOR = >=, + NEGATOR = >, + RESTRICT = scalarlesel, + JOIN = scalarlejoinsel +); + +--! @brief Greater-than on jsonb_entry via ore_cllw. +--! @param a eql_v3.jsonb_entry Left operand +--! @param b eql_v3.jsonb_entry Right operand +--! @return boolean True if a is greater than b +CREATE FUNCTION eql_v3.gt(a eql_v3.jsonb_entry, b eql_v3.jsonb_entry) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ore_cllw(a) > eql_v3.ore_cllw(b) +$$; + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.jsonb_entry, + RIGHTARG = eql_v3.jsonb_entry, + COMMUTATOR = <, + NEGATOR = <=, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel +); + +--! @brief Greater-than-or-equal on jsonb_entry via ore_cllw. +--! @param a eql_v3.jsonb_entry Left operand +--! @param b eql_v3.jsonb_entry Right operand +--! @return boolean True if a is greater than or equal to b +CREATE FUNCTION eql_v3.gte(a eql_v3.jsonb_entry, b eql_v3.jsonb_entry) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ore_cllw(a) >= eql_v3.ore_cllw(b) +$$; + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.jsonb_entry, + RIGHTARG = eql_v3.jsonb_entry, + COMMUTATOR = <=, + NEGATOR = <, + RESTRICT = scalargesel, + JOIN = scalargejoinsel +); + +--! @file v3/jsonb/blockers.sql +--! @brief Native-jsonb firewall for eql_v3.json. +--! +--! eql_v3.json SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons +--! = <> < <= > >= are supported on eql_v3.jsonb_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 +--! route to plaintext-jsonb semantics. The blocked set is KNOWN_JSONB_OPERATORS +--! minus the supported ops: ? ?| ?& @? @@ #> #>> - #- ||. +--! +--! Each blocker is LANGUAGE plpgsql (NEVER STRICT — a STRICT blocker would let +--! PostgreSQL skip the body and return NULL on a NULL argument, bypassing the +--! exception) and delegates to the shared eql_v3.encrypted_domain_unsupported_* +--! helpers. Each blocker's RETURNS type matches the native operator it shadows +--! (#> -> jsonb, #>> -> text, - / #- / || -> jsonb; the rest are boolean) so a +--! composed expression resolves and the body raises 'operator not supported', +--! rather than failing earlier with a misleading 'operator does not exist' on a +--! boolean intermediate. The bound operator must resolve before native fallback, +--! so the firewall fires. + +--! @brief Blocker: ? (key/element exists). +--! @param a eql_v3.json 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 eql_v3.json, b text) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '?'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal.jsonb_blocked_exists, + LEFTARG = eql_v3.json, + RIGHTARG = text +); + +--! @brief Blocker: ?| (any key exists). +--! @param a eql_v3.json 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 eql_v3.json, b text[]) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '?|'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal.jsonb_blocked_exists_any, + LEFTARG = eql_v3.json, + RIGHTARG = text[] +); + +--! @brief Blocker: ?& (all keys exist). +--! @param a eql_v3.json 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 eql_v3.json, b text[]) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '?&'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal.jsonb_blocked_exists_all, + LEFTARG = eql_v3.json, + RIGHTARG = text[] +); + +--! @brief Blocker: @? (jsonpath exists). +--! @param a eql_v3.json 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 eql_v3.json, b jsonpath) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '@?'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_exists, + LEFTARG = eql_v3.json, + RIGHTARG = jsonpath +); + +--! @brief Blocker: @@ (jsonpath predicate). +--! @param a eql_v3.json 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 eql_v3.json, b jsonpath) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '@@'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_match, + LEFTARG = eql_v3.json, + RIGHTARG = jsonpath +); + +--! @brief Blocker: #> (path extract, native returns jsonb). +--! @param a eql_v3.json 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 eql_v3.json, b text[]) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '#>'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal.jsonb_blocked_path_extract, + LEFTARG = eql_v3.json, + RIGHTARG = text[] +); + +--! @brief Blocker: #>> (path extract as text). +--! @param a eql_v3.json 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 eql_v3.json, b text[]) +RETURNS text +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_text('eql_v3.json', '#>>'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal.jsonb_blocked_path_extract_text, + LEFTARG = eql_v3.json, + RIGHTARG = text[] +); + +--! @brief Blocker: - (delete key, text RHS; native returns jsonb). +--! @param a eql_v3.json 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 eql_v3.json, b text) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '-'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal.jsonb_blocked_delete_text, + LEFTARG = eql_v3.json, + RIGHTARG = text +); + +--! @brief Blocker: - (delete index, integer RHS). +--! @param a eql_v3.json 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 eql_v3.json, b integer) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '-'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal.jsonb_blocked_delete_int, + LEFTARG = eql_v3.json, + RIGHTARG = integer +); + +--! @brief Blocker: - (delete keys, text[] RHS). +--! @param a eql_v3.json 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 eql_v3.json, b text[]) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '-'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal.jsonb_blocked_delete_array, + LEFTARG = eql_v3.json, + RIGHTARG = text[] +); + +--! @brief Blocker: #- (delete at path). +--! @param a eql_v3.json 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 eql_v3.json, b text[]) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '#-'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal.jsonb_blocked_delete_path, + LEFTARG = eql_v3.json, + RIGHTARG = text[] +); + +--! @brief Blocker: || (concatenate, encrypted on the left). +--! @param a eql_v3.json 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 eql_v3.json, b jsonb) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '||'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal.jsonb_blocked_concat, + LEFTARG = eql_v3.json, + RIGHTARG = jsonb +); + +--! @brief Blocker: || (concatenate, encrypted on the right). +--! @param a jsonb Native LHS operand. +--! @param b eql_v3.json 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 eql_v3.json) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '||'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal.jsonb_blocked_concat_rhs, + LEFTARG = jsonb, + RIGHTARG = eql_v3.json +); + +------------------------------------------------------------------------------ +-- Root-document comparison blockers. +------------------------------------------------------------------------------ + +--! @brief Blocker: root eql_v3.json document comparisons. +--! @param a eql_v3.json Left operand (encrypted payload). +--! @param b eql_v3.json Right operand (encrypted payload). +--! @return boolean Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_json(a eql_v3.json, b eql_v3.json) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', 'comparison'); +END; +$$ LANGUAGE plpgsql; + +--! @brief Blocker: root eql_v3.json-to-jsonb comparisons. +--! @param a eql_v3.json 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 eql_v3.json, b jsonb) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', 'comparison'); +END; +$$ LANGUAGE plpgsql; + +--! @brief Blocker: root jsonb-to-eql_v3.json comparisons. +--! @param a jsonb Native LHS operand. +--! @param b eql_v3.json 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 eql_v3.json) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', 'comparison'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, + LEFTARG = eql_v3.json, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = eql_v3.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, + LEFTARG = eql_v3.json, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = eql_v3.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, + LEFTARG = eql_v3.json, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = eql_v3.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, + LEFTARG = eql_v3.json, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = eql_v3.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, + LEFTARG = eql_v3.json, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = eql_v3.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, + LEFTARG = eql_v3.json, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = eql_v3.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = eql_v3.json +); + +------------------------------------------------------------------------------ +-- Mixed jsonb containment blockers. +------------------------------------------------------------------------------ + +--! @brief Blocker: @> with encrypted root document and native jsonb. +--! @param a eql_v3.json 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 eql_v3.json, b jsonb) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '@>'); +END; +$$ LANGUAGE plpgsql; + +--! @brief Blocker: @> with native jsonb and encrypted root document. +--! @param a jsonb Native LHS operand. +--! @param b eql_v3.json 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 eql_v3.json) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '@>'); +END; +$$ LANGUAGE plpgsql; + +--! @brief Blocker: <@ with encrypted root document and native jsonb. +--! @param a eql_v3.json 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 eql_v3.json, b jsonb) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '<@'); +END; +$$ LANGUAGE plpgsql; + +--! @brief Blocker: <@ with native jsonb and encrypted root document. +--! @param a jsonb Native LHS operand. +--! @param b eql_v3.json 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 eql_v3.json) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '<@'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.jsonb_blocked_contains_json_jsonb, + LEFTARG = eql_v3.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.jsonb_blocked_contains_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.jsonb_blocked_contained_json_jsonb, + LEFTARG = eql_v3.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.jsonb_blocked_contained_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = eql_v3.json +); + +--! @file v3/jsonb/aggregates.sql +--! @brief min / max aggregates over eql_v3.jsonb_entry. +--! +--! SteVec document entries extracted at a selector (`doc -> 'sel'`) order by +--! their CLLW ORE (`oc`) term, so the extremum is picked by comparing +--! `eql_v3.ore_cllw(entry)` rather than the scalar Block-ORE `ord_term` the +--! generated scalar ord aggregates use. 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 `oc`-carrying entries are orderable.** `eql_v3.ore_cllw(entry)` +--! returns NULL when an entry has no `oc` (CLLW ORE) term — the same entries a +--! `eql_v3.ore_cllw` btree NULL-filters from range scans. The state functions +--! therefore IGNORE `oc`-less entries (they never become or survive as the +--! extremum), so `min`/`max` is well-defined over a mix of `oc`-carrying and +--! `oc`-less entries and is not corrupted by an `oc`-less seed. A naive +--! `ore_cllw(value) < ore_cllw(state)` would be NULL whenever either side +--! lacks `oc`, pinning a wrong (`oc`-less) extremum when the first aggregated +--! row is `oc`-less. An all-`oc`-less input has no orderable extremum and +--! returns the (arbitrary) STRICT seed. + +--! @brief State function for min on eql_v3.jsonb_entry. +--! +--! Keeps whichever orderable entry has the lesser CLLW ORE term. STRICT, so SQL +--! NULL entries are skipped by the aggregate machinery; `oc`-less (non-orderable) +--! entries are skipped explicitly (see the @note on this file). +--! +--! @param state eql_v3.jsonb_entry Running extremum. +--! @param value eql_v3.jsonb_entry Candidate entry. +--! @return eql_v3.jsonb_entry The lesser orderable entry by `ore_cllw`. +CREATE FUNCTION eql_v3_internal.jsonb_entry_min_sfunc( + state eql_v3.jsonb_entry, + value eql_v3.jsonb_entry +) +RETURNS eql_v3.jsonb_entry +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +DECLARE + value_ore eql_v3_internal.ore_cllw := eql_v3.ore_cllw(value); + state_ore eql_v3_internal.ore_cllw := eql_v3.ore_cllw(state); +BEGIN + -- A non-orderable (oc-less) candidate never replaces the running extremum. + IF value_ore IS NULL THEN + RETURN state; + END IF; + -- Adopt the candidate when the running extremum is itself non-orderable + -- (e.g. an oc-less STRICT seed) or strictly greater. + IF state_ore IS NULL OR value_ore < state_ore THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate over eql_v3.jsonb_entry. +--! @param input eql_v3.jsonb_entry +--! @return eql_v3.jsonb_entry The entry with the smallest CLLW ORE term. +CREATE AGGREGATE eql_v3.min(eql_v3.jsonb_entry) ( + sfunc = eql_v3_internal.jsonb_entry_min_sfunc, + stype = eql_v3.jsonb_entry, + combinefunc = eql_v3_internal.jsonb_entry_min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.jsonb_entry. +--! +--! Keeps whichever orderable entry has the greater CLLW ORE term. `oc`-less +--! entries are skipped, mirroring `jsonb_entry_min_sfunc` (see the file @note). +--! +--! @param state eql_v3.jsonb_entry Running extremum. +--! @param value eql_v3.jsonb_entry Candidate entry. +--! @return eql_v3.jsonb_entry The greater orderable entry by `ore_cllw`. +CREATE FUNCTION eql_v3_internal.jsonb_entry_max_sfunc( + state eql_v3.jsonb_entry, + value eql_v3.jsonb_entry +) +RETURNS eql_v3.jsonb_entry +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +DECLARE + value_ore eql_v3_internal.ore_cllw := eql_v3.ore_cllw(value); + state_ore eql_v3_internal.ore_cllw := eql_v3.ore_cllw(state); +BEGIN + -- A non-orderable (oc-less) candidate never replaces the running extremum. + IF value_ore IS NULL THEN + RETURN state; + END IF; + -- Adopt the candidate when the running extremum is itself non-orderable + -- (e.g. an oc-less STRICT seed) or strictly lesser. + IF state_ore IS NULL OR value_ore > state_ore THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate over eql_v3.jsonb_entry. +--! @param input eql_v3.jsonb_entry +--! @return eql_v3.jsonb_entry The entry with the largest CLLW ORE term. +CREATE AGGREGATE eql_v3.max(eql_v3.jsonb_entry) ( + sfunc = eql_v3_internal.jsonb_entry_max_sfunc, + stype = eql_v3.jsonb_entry, + combinefunc = eql_v3_internal.jsonb_entry_max_sfunc, + parallel = safe +); +--! @file pin_search_path_v3.sql +--! @brief Post-install: pin search_path on every eql_v3.* function. +--! +--! Appended verbatim by `tasks/build.sh` to the end of the v3-only release +--! artifact, AFTER all src/v3/**/*.sql files have been concatenated. It lives +--! outside src/ so it stays out of the dependency graph. +--! +--! Iterates over functions in the `eql_v3` and `eql_v3_internal` schemas and +--! applies a fixed `search_path` via `ALTER FUNCTION ... SET search_path = ...`, +--! satisfying Supabase splinter's `function_search_path_mutable` lint. +--! +--! @note A SET clause disables SQL-function inlining. The inline-critical SEM +--! helpers (ore_block_256_*, ore_cllw_*, ore_cllw/has_ore_cllw, +--! ope_cllw, hmac_256, bloom_filter over jsonb) and the +--! encrypted-domain family (recognised structurally) are deliberately +--! left unpinned. +--! @see tasks/test/splinter.sh +--! @see tasks/build.sh + +DO $$ +DECLARE + fn_oid oid; + inline_critical_oids oid[]; + jsonb_oid oid; +BEGIN + SELECT t.oid INTO jsonb_oid + FROM pg_catalog.pg_type t + JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace + WHERE n.nspname = 'pg_catalog' AND t.typname = 'jsonb'; + + IF jsonb_oid IS NULL THEN + RAISE EXCEPTION 'pin_search_path_v3: type pg_catalog.jsonb not found'; + END IF; + + -- eql_v3 SEM index-term functions that must stay inlinable for + -- functional-index matching (no SET, IMMUTABLE). Mirrors the eql_v3 clause + -- in the legacy combined pin_search_path.sql. + SELECT pg_catalog.array_agg(p.oid) INTO inline_critical_oids + FROM pg_catalog.pg_proc p + JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace + WHERE n.nspname = ANY(eql_v3_internal.owned_schemas()) + AND ( + (p.pronargs = 2 + AND p.proname IN ('ore_block_256_eq', 'ore_block_256_neq', + 'ore_block_256_lt', 'ore_block_256_lte', + 'ore_block_256_gt', 'ore_block_256_gte')) + OR (p.pronargs = 2 + AND p.proname IN ('ore_cllw_eq', 'ore_cllw_neq', + 'ore_cllw_lt', 'ore_cllw_lte', + 'ore_cllw_gt', 'ore_cllw_gte')) + OR (p.pronargs = 1 + AND p.proname IN ('ore_cllw', 'has_ore_cllw') + AND p.proargtypes[0] = jsonb_oid) + -- The CLLW-OPE surface is the extractor alone: eql_v3_internal.ope_cllw is a + -- domain over bytea (native comparison operators and btree opclass), + -- so there are no ope-specific comparison functions to keep inlinable. + OR (p.pronargs = 1 + AND p.proname = 'ope_cllw' + AND p.proargtypes[0] = jsonb_oid) + OR (p.pronargs = 1 + AND p.proname = 'hmac_256' + AND p.proargtypes[0] = jsonb_oid) + OR (p.pronargs = 1 + AND p.proname = 'bloom_filter' + AND p.proargtypes[0] = jsonb_oid) + ); + + FOR fn_oid IN + SELECT p.oid + FROM pg_catalog.pg_proc p + JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace + WHERE n.nspname = ANY(eql_v3_internal.owned_schemas()) + AND p.prokind IN ('f', 'w') + AND NOT EXISTS ( + SELECT 1 FROM pg_catalog.unnest(coalesce(p.proconfig, '{}'::text[])) c + WHERE c LIKE 'search_path=%' + ) + AND NOT (p.oid = ANY (coalesce(inline_critical_oids, '{}'::oid[]))) + -- Encrypted-domain family — structural skip: LANGUAGE sql, IMMUTABLE, + -- taking >=1 argument typed as a jsonb-backed DOMAIN in eql_v3. + AND NOT ( + p.prolang = (SELECT l.oid FROM pg_catalog.pg_language l + WHERE l.lanname = 'sql') + AND p.provolatile = 'i' + AND EXISTS ( + SELECT 1 + FROM pg_catalog.unnest(p.proargtypes::oid[]) AS arg(typ) + JOIN pg_catalog.pg_type dt ON dt.oid = arg.typ + JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace + WHERE dt.typtype = 'd' + AND dt.typbasetype = jsonb_oid + AND dn.nspname = ANY(eql_v3_internal.owned_schemas()) + ) + ) + -- Comment-marker fallback for hand-written inline-critical extension + -- functions that take no domain argument. + AND NOT EXISTS ( + SELECT 1 FROM pg_catalog.pg_description d + WHERE d.objoid = p.oid + AND d.classoid = 'pg_catalog.pg_proc'::regclass + AND d.description LIKE 'eql-inline-critical%' + ) + LOOP + EXECUTE pg_catalog.format( + 'ALTER FUNCTION %s SET search_path = pg_catalog, extensions, public', + fn_oid::regprocedure + ); + END LOOP; +END $$; diff --git a/packages/cli/tests/helpers/run.ts b/packages/cli/tests/helpers/run.ts index 91254296..38c6cf03 100644 --- a/packages/cli/tests/helpers/run.ts +++ b/packages/cli/tests/helpers/run.ts @@ -59,19 +59,24 @@ export function run(args: string[], opts: RunOptions = {}): Promise<RunResult> { let stdout = '' let stderr = '' + // Preserve the true interleaving order of the combined transcript by + // recording chunks as they arrive, while keeping stdout/stderr separate. + const chunks: string[] = [] child.stdout.setEncoding('utf8') child.stderr.setEncoding('utf8') child.stdout.on('data', (d: string) => { stdout += d + chunks.push(d) }) child.stderr.on('data', (d: string) => { stderr += d + chunks.push(d) }) return new Promise<RunResult>((res, rej) => { child.on('error', rej) child.on('close', (code, signal) => { - res(buildRunResult(code, signal, stdout, stderr)) + res(buildRunResult(code, signal, stdout, stderr, chunks.join(''))) }) }) } @@ -83,14 +88,20 @@ export function run(args: string[], opts: RunOptions = {}): Promise<RunResult> { * `code`/`signal` is non-null on `'close'` — this must never coerce a null * `code` to `0`, or a signal-terminated child (crash, SIGKILL, OOM) would be * misreported as a clean exit. + * + * `raw` defaults to `stdout + stderr` (fine for the unit tests below, which + * pass pre-baked strings with no real interleaving to preserve); `run()` + * itself always passes the chunk-interleaved transcript explicitly, since + * naive concatenation can reorder output relative to a real child process's + * actual stdout/stderr write sequence. */ export function buildRunResult( code: number | null, signal: NodeJS.Signals | null, stdout: string, stderr: string, + raw: string = stdout + stderr, ): RunResult { - const raw = stdout + stderr return { exitCode: code, signal, diff --git a/packages/stack/__tests__/cjs-require.test.ts b/packages/stack/__tests__/cjs-require.test.ts index 1a79ec46..0b530fd5 100644 --- a/packages/stack/__tests__/cjs-require.test.ts +++ b/packages/stack/__tests__/cjs-require.test.ts @@ -83,6 +83,27 @@ describe('CJS consumers can require the built bundles', () => { it('discovers at least the public entry points', () => { expect(cjsEntries).toContain('dist/index.cjs') expect(cjsEntries).toContain('dist/encryption/index.cjs') + expect(cjsEntries).toContain('dist/eql/v3/index.cjs') + }) + + it('exposes the v3 `types` namespace + table API from the CJS bundle', () => { + const v3Bundle = path.join(distDir, 'eql', 'v3', 'index.cjs') + const script = [ + `const v3 = require(${JSON.stringify(v3Bundle)})`, + `if (typeof v3.encryptedTable !== 'function') { throw new Error('missing v3 CJS export: encryptedTable') }`, + `if (typeof v3.buildEncryptConfig !== 'function') { throw new Error('missing v3 CJS export: buildEncryptConfig') }`, + `if (typeof v3.types !== 'object' || v3.types === null) { throw new Error('missing v3 CJS export: types namespace') }`, + `const requiredTypes = ['TextSearch', 'TextEq', 'IntegerOrd', 'Boolean', 'Timestamp']`, + `const missing = requiredTypes.filter((k) => typeof v3.types[k] !== 'function')`, + `if (missing.length > 0) { throw new Error('missing v3 types.* CJS members: ' + missing.join(', ')) }`, + ].join('\n') + + expect(() => + execFileSync(process.execPath, ['-e', script], { + cwd: packageRoot, + stdio: 'pipe', + }), + ).not.toThrow() }) it.each( diff --git a/packages/stack/__tests__/encrypt-lock-context-guards.test.ts b/packages/stack/__tests__/encrypt-lock-context-guards.test.ts new file mode 100644 index 00000000..6c88f145 --- /dev/null +++ b/packages/stack/__tests__/encrypt-lock-context-guards.test.ts @@ -0,0 +1,110 @@ +/** + * Offline guard tests for the lock-context encrypt path. + * + * `EncryptOperationWithLockContext.execute()` re-applies the NaN / Infinity + * runtime guards that the non-lock `EncryptOperation.execute()` has. The + * non-lock guards are exercised by the live `number-protect.test.ts` (its + * `beforeAll` builds a real client), but the lock-context arm — reached via + * `encrypt(value).withLockContext(...)` — had no coverage in any suite. These + * tests mock `@cipherstash/protect-ffi` so they run in CI without credentials + * and assert that: + * 1. NaN / +Infinity / -Infinity are rejected as failures with the same + * messages as the non-lock path, and + * 2. the guard short-circuits *before* the FFI encrypt call (a leaked NaN + * must never reach the ciphertext boundary). + * + * Every case runs against both a v2 fluent-builder column and a v3 domain + * column: the guards live on the shared `EncryptOperationWithLockContext`, so + * both schema styles must take the identical short-circuit path. Each style + * gets its own client — one client emits exactly one EQL wire format, so + * `Encryption` rejects a mixed v2 + v3 schema set outright. + */ + +import { beforeEach, describe, expect, it, vi } from 'vitest' +import { encryptedTable as encryptedTableV3, types } from '@/eql/v3' +import { LockContext } from '@/identity' +import { Encryption } from '@/index' +import { encryptedColumn, encryptedTable } from '@/schema' + +vi.mock('@cipherstash/protect-ffi', () => ({ + // `getErrorCode` does `error instanceof ProtectError` on the failure path, + // so the mock must export the class even though the guards throw plain Errors. + ProtectError: class ProtectError extends Error {}, + newClient: vi.fn(async () => ({ __mock: 'client' })), + encrypt: vi.fn(async () => ({ v: 2, c: 'ciphertext' })), + decrypt: vi.fn(async () => 'decrypted'), +})) + +import * as ffi from '@cipherstash/protect-ffi' + +const users = encryptedTable('users', { + score: encryptedColumn('score').dataType('number').equality().orderAndRange(), +}) + +const usersV3 = encryptedTableV3('users_v3', { + score: types.IntegerOrd('score'), +}) + +// biome-ignore lint/suspicious/noExplicitAny: test helper reads the Result union +const failure = (result: any) => result.failure + +const clients: Record< + 'v2 fluent builder' | 'v3 domain type', + Awaited<ReturnType<typeof Encryption>> +> = {} as never + +beforeEach(async () => { + vi.clearAllMocks() + process.env.CS_WORKSPACE_CRN = 'crn:ap-southeast-2.aws:test-workspace' + clients['v2 fluent builder'] = await Encryption({ schemas: [users] }) + clients['v3 domain type'] = await Encryption({ schemas: [usersV3] }) +}) + +describe.each([ + ['v2 fluent builder', { column: users.score, table: users }], + ['v3 domain type', { column: usersV3.score, table: usersV3 }], +] as const)('encrypt with lock context rejects non-finite numbers (%s)', (variant, target) => { + const client = () => clients[variant] + it('rejects NaN and never reaches the FFI', async () => { + const result = await client() + .encrypt(Number.NaN, target) + .withLockContext(new LockContext()) + + expect(failure(result)).toBeDefined() + expect(failure(result)?.message).toContain('Cannot encrypt NaN value') + expect(vi.mocked(ffi.encrypt)).not.toHaveBeenCalled() + }) + + it('rejects +Infinity and never reaches the FFI', async () => { + const result = await client() + .encrypt(Number.POSITIVE_INFINITY, target) + .withLockContext(new LockContext()) + + expect(failure(result)).toBeDefined() + expect(failure(result)?.message).toContain('Cannot encrypt Infinity value') + expect(vi.mocked(ffi.encrypt)).not.toHaveBeenCalled() + }) + + it('rejects -Infinity and never reaches the FFI', async () => { + const result = await client() + .encrypt(Number.NEGATIVE_INFINITY, target) + .withLockContext(new LockContext()) + + expect(failure(result)).toBeDefined() + expect(failure(result)?.message).toContain('Cannot encrypt Infinity value') + expect(vi.mocked(ffi.encrypt)).not.toHaveBeenCalled() + }) + + it('accepts a finite number and forwards it to the FFI', async () => { + // Positive control: proves the guards above reject *because* of the value, + // not because the lock-context path is broken for all numbers. + const result = await client() + .encrypt(42, target) + .withLockContext(new LockContext()) + + expect(failure(result)).toBeUndefined() + expect(vi.mocked(ffi.encrypt)).toHaveBeenCalledTimes(1) + const opts = vi.mocked(ffi.encrypt).mock.calls[0][1] + expect(opts.plaintext).toBe(42) + }) +}) diff --git a/packages/stack/__tests__/error-codes.test.ts b/packages/stack/__tests__/error-codes.test.ts index 80ecbc0f..e4cbc97c 100644 --- a/packages/stack/__tests__/error-codes.test.ts +++ b/packages/stack/__tests__/error-codes.test.ts @@ -246,15 +246,16 @@ describe('FFI Error Code Preservation', () => { describe('bulkDecrypt error codes', () => { it( - 'returns undefined code for malformed ciphertexts (non-FFI validation)', + 'returns per-item errors for malformed ciphertexts (fallible FFI decrypt)', async () => { - // bulkDecrypt uses the "fallible" FFI API (decryptBulkFallible) which normally: + // bulkDecrypt uses the "fallible" FFI API (decryptBulkFallible): // - Succeeds at the operation level // - Returns per-item results with either { data } or { error } // - // However, malformed ciphertexts cause parsing errors BEFORE the fallible API, - // which throws and triggers a top-level failure (not per-item errors). - // These pre-FFI errors don't have structured FFI error codes. + // protect-ffi < 0.27 threw a top-level pre-FFI parsing error for + // malformed ciphertexts; 0.27 moved ciphertext parsing INTO the + // fallible API (structured as INVALID_CIPHERTEXT), so the operation + // now succeeds and each bad item carries its own { error } result. const invalidCiphertexts = [ { data: { i: { t: 'test_table', c: 'email' }, v: 2, c: 'invalid1' } }, { data: { i: { t: 'test_table', c: 'email' }, v: 2, c: 'invalid2' } }, @@ -262,10 +263,13 @@ describe('FFI Error Code Preservation', () => { const result = await protectClient.bulkDecrypt(invalidCiphertexts) - expect(result.failure).toBeDefined() - expect(result.failure?.type).toBe(EncryptionErrorTypes.DecryptionError) - // FFI parsing errors don't have structured error codes - expect(result.failure?.code).toBeUndefined() + expect(result.failure).toBeUndefined() + if (result.failure) throw new Error('unreachable: asserted above') + expect(result.data).toHaveLength(2) + for (const item of result.data) { + expect(item).toHaveProperty('error') + expect((item as { error?: unknown }).error).toBeTruthy() + } }, FFI_TEST_TIMEOUT, ) diff --git a/packages/stack/__tests__/fixtures/eql-v3/cipherstash-encrypt-v3.sql b/packages/stack/__tests__/fixtures/eql-v3/cipherstash-encrypt-v3.sql new file mode 100644 index 00000000..08da1ff8 --- /dev/null +++ b/packages/stack/__tests__/fixtures/eql-v3/cipherstash-encrypt-v3.sql @@ -0,0 +1,36278 @@ +--! @file v3/schema.sql +--! @brief EQL v3 schema creation +--! +--! Creates the eql_v3 and eql_v3_internal schemas. eql_v3 is the public API: +--! the self-contained encrypted-domain type families (eql_v3.integer, eql_v3.bigint, +--! and future scalar domains) — their jsonb-backed domains, index-term +--! extractors, aggregates, AND the operator-backing comparison wrappers +--! (eq/neq/lt/lte/gt/gte/contains/contained_by, plus the jsonb containment +--! helpers). The wrappers are public because they are the function-form +--! equivalent of every supported operator: platforms without operator support +--! (Supabase/PostgREST calls functions, not operators) invoke them by name. +--! eql_v3_internal houses INTERNAL implementation objects only: the +--! searchable-encrypted-metadata (SEM) index-term types +--! (eql_v3_internal.hmac_256, eql_v3_internal.ore_block_256) and their support +--! functions, the unsupported-operator blockers (which only raise), and the +--! aggregate state functions. Together the two schemas are self-contained — +--! they own every type they need and have no runtime dependency on another EQL +--! schema. +--! +--! Drops existing schema if present to support clean reinstallation. +--! +--! @warning DROP SCHEMA CASCADE will remove all objects in the schema +--! @note eql_v3 is a new, additional schema for the encrypted-domain families. +--! +--! @note DESIGN DECISION — EQL never grants permissions automatically. This +--! installer issues no GRANT (or REVOKE) on eql_v3 or eql_v3_internal: +--! access is strictly opt-in. A deployment that exposes EQL to +--! non-owner roles (e.g. Supabase `authenticated`/`anon` via PostgREST) +--! must explicitly `GRANT USAGE ON SCHEMA eql_v3` and `GRANT EXECUTE` on +--! the functions it needs. This is intentional least-privilege, not an +--! oversight — see docs/reference/permissions.md. eql_v3_internal is not +--! part of the public API and normally needs no grant; where a caller +--! reaches an internal object indirectly (a public operator/aggregate +--! whose backing state-fn/blocker lives there), grant it deliberately. + +--! @brief Drop existing EQL v3 schema +--! @warning CASCADE will drop all dependent objects +DROP SCHEMA IF EXISTS eql_v3 CASCADE; + +--! @brief Create EQL v3 schema +--! @note Houses the encrypted-domain type families +CREATE SCHEMA eql_v3; + +--! @brief Drop existing EQL v3 internal schema +--! @warning CASCADE will drop all dependent objects +DROP SCHEMA IF EXISTS eql_v3_internal CASCADE; + +--! @brief Create EQL v3 internal implementation schema +--! @note Houses INTERNAL eql_v3 objects only: SEM index-term TYPES + their +--! support/constructor/comparator functions, the unsupported-operator +--! blockers (which only raise), the aggregate state functions, and the +--! SteVec CHECK validators. Kept out of the public `eql_v3` surface so +--! internal index-term TYPES do not clutter the Supabase Table Builder +--! type picker. NOTE: the operator-backing comparison *wrappers* are NOT +--! here — they are public in `eql_v3` so every operator has a callable +--! function equivalent for platforms without operator support. +CREATE SCHEMA eql_v3_internal; +COMMENT ON SCHEMA eql_v3_internal IS + 'EQL internal implementation detail; not a public API surface.'; + +--! @brief Schemas owned by the eql_v3 surface +--! +--! Single source of truth for tooling that must enumerate every schema this +--! installer owns (`eql_v3.lints()`, `tasks/pin_search_path_v3.sql`), so a +--! future third eql_v3-family schema is one array literal to edit instead of +--! a hardcoded schema-name predicate repeated at every call site. Keep in +--! sync with the `SCHEMA` / `INTERNAL_SCHEMA` constants in +--! `crates/eql-codegen/src/consts.rs` — those drive what codegen emits into +--! each schema; this drives what tooling scans across both. +--! +--! @return name[] The schema names eql_v3 owns (public + internal). +CREATE FUNCTION eql_v3_internal.owned_schemas() + RETURNS name[] + LANGUAGE sql IMMUTABLE PARALLEL SAFE +AS $$ + SELECT ARRAY['eql_v3', 'eql_v3_internal']::name[] +$$; + +--! @file v3/crypto.sql +--! @brief PostgreSQL pgcrypto extension enablement (eql_v3 fork) +--! +--! Forked from src/crypto.sql (design D8) so the entire eql_v3 dependency +--! closure lives under src/v3/. Enables the pgcrypto extension which provides +--! cryptographic functions used by the eql_v3 ORE comparison path. +--! +--! Installs pgcrypto into the `extensions` schema (Supabase convention) to +--! avoid the `extension_in_public` lint. Every EQL function that uses pgcrypto +--! has `pg_catalog, extensions, public` on its `search_path`, so a pre-existing +--! install in `public` keeps working — and a pre-existing install anywhere else +--! will be rejected at install time. The body is idempotent +--! (`CREATE SCHEMA IF NOT EXISTS`, `pg_extension` guard), so running it +--! alongside the eql_v2 copy in a combined install is safe. +--! +--! @note pgcrypto provides functions like digest(), hmac(), gen_random_bytes() + +--! @brief Create extensions schema (Supabase convention) +CREATE SCHEMA IF NOT EXISTS extensions; + +--! @brief Enable pgcrypto extension and validate its schema +DO $$ +DECLARE + pgcrypto_schema name; +BEGIN + IF NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'pgcrypto') THEN + CREATE EXTENSION pgcrypto WITH SCHEMA extensions; + END IF; + + SELECT n.nspname INTO pgcrypto_schema + FROM pg_extension e + JOIN pg_namespace n ON n.oid = e.extnamespace + WHERE e.extname = 'pgcrypto'; + + IF pgcrypto_schema = 'extensions' THEN + -- expected location, nothing to say + NULL; + ELSIF pgcrypto_schema = 'public' THEN + RAISE NOTICE + 'pgcrypto is installed in the `public` schema. EQL works against this layout, ' + 'but Supabase splinter will flag it as `extension_in_public`. Move it with: ' + 'ALTER EXTENSION pgcrypto SET SCHEMA extensions'; + ELSE + RAISE EXCEPTION + 'pgcrypto is installed in schema `%`, which is not on the EQL function search_path ' + '(pg_catalog, extensions, public). EQL cryptographic operations would fail at ' + 'runtime. Relocate the extension before installing EQL: ' + 'ALTER EXTENSION pgcrypto SET SCHEMA extensions', + pgcrypto_schema; + END IF; +END $$; + +--! @file v3/common.sql +--! @brief Common utility functions for the self-contained eql_v3 surface. +--! +--! Forked from src/common.sql (design D7) so the eql_v3 ORE constructor owns the +--! one transitive helper it needs without reaching into another schema. The +--! eql_v2 original is unchanged. + +--! @brief Convert JSONB hex array to bytea array +--! @internal +--! +--! Converts a JSONB array of hex-encoded strings into a PostgreSQL bytea array. +--! Used for deserializing binary data (like ORE terms) from JSONB storage. +--! +--! @param val jsonb JSONB array of hex-encoded strings +--! @return bytea[] Array of decoded binary values +--! +--! @note Returns NULL if input is JSON null +--! @note Each array element is hex-decoded to bytea +--! @note Inlinable `LANGUAGE sql` IMMUTABLE form (no `SET search_path`) so the +--! planner can fold this per-encrypted-value helper into the calling query. +--! This deliberately diverges from the v2 plpgsql equivalent (intentionally +--! left unchanged): the `CASE WHEN jsonb_typeof(val) = 'array'` guard only +--! evaluates the set-returning `jsonb_array_elements_text` for an array, so a +--! non-array JSON scalar returns NULL here instead of raising "cannot extract +--! elements from a scalar". Both callers only ever pass an array or JSON null +--! (`val->'ob'`), so the divergence is unreachable in practice; JSON null and +--! empty array still return NULL exactly as before. +CREATE FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(val jsonb) +RETURNS bytea[] + IMMUTABLE +AS $$ + SELECT CASE WHEN jsonb_typeof(val) = 'array' + THEN ( + SELECT array_agg(decode(value::text, 'hex')::bytea) + FROM jsonb_array_elements_text(val) AS value + ) + ELSE NULL + END; +$$ LANGUAGE sql; + +--! @internal Mark this hand-written helper inline-critical so the post-install +--! pin_search_path pass leaves it unpinned (no `SET search_path`), preserving +--! SQL-function inlining. It takes a bare `jsonb` arg (not a jsonb-backed +--! encrypted DOMAIN), so the structural skip in tasks/pin_search_path_v3.sql does +--! not recognise it; this marker is the documented manual opt-in. +COMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(jsonb) IS + 'eql-inline-critical: per-encrypted-value ORE helper; must stay inlinable (unpinned search_path)'; + +--! @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/sem/ore_block_256/functions.sql +--! @brief ORE block construction, extraction, and comparison (eql_v3 SEM). +--! +--! jsonb-only subset of src/ore_block_u64_8_256/functions.sql. The +--! encrypted-column overloads are omitted; the helper jsonb_array_to_bytea_array +--! and pgcrypto encrypt() are reached via the forked src/v3/common.sql and +--! src/v3/crypto.sql so the whole closure stays under src/v3. (Doc comments +--! deliberately avoid naming eql_v2 symbols so the self-containment grep stays +--! clean.) + +--! @brief Convert JSONB array to ORE block composite type +--! @internal +--! @param val jsonb Array of hex-encoded ORE block terms +--! @return eql_v3_internal.ore_block_256 ORE block composite, or NULL if input is null +--! @note Inlinable `LANGUAGE sql` IMMUTABLE form (no `SET search_path`) so the +--! planner can fold this per-encrypted-value helper into the calling query. +--! This deliberately diverges from the v2 plpgsql equivalent (intentionally +--! left unchanged): the `CASE WHEN jsonb_typeof(val) = 'array'` guard only +--! evaluates the array path for an array, so a non-array JSON scalar returns +--! NULL here instead of raising. The sole caller (`ore_block_256`) only reaches +--! this when `has_ore_block_256(val)` is true, which now requires `val->'ob'` +--! to be a JSON array, so the non-array branch is unreachable in practice. +--! An empty array (`ob: []`, what encrypting the empty string `""` produces) +--! yields a non-NULL composite with an EMPTY `terms` array — NOT NULL terms. +--! The `COALESCE` is load-bearing: `array_agg` over zero rows returns NULL, and +--! NULL terms make the comparator return NULL (so an empty-text row silently +--! drops out of ordered queries). An empty array instead engages the +--! comparator's `cardinality = 0` guard, which sorts empty BEFORE every +--! non-empty term. See issue #262 (pinned by T7). +CREATE FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(val jsonb) +RETURNS eql_v3_internal.ore_block_256 + IMMUTABLE +AS $$ + SELECT CASE WHEN jsonb_typeof(val) = 'array' + THEN ROW(COALESCE( + ( + SELECT array_agg(ROW(b)::eql_v3_internal.ore_block_256_term) + FROM unnest(eql_v3_internal.jsonb_array_to_bytea_array(val)) AS b + ), + ARRAY[]::eql_v3_internal.ore_block_256_term[] + ))::eql_v3_internal.ore_block_256 + ELSE NULL + END; +$$ LANGUAGE sql; + +--! @internal Mark this hand-written helper inline-critical so the post-install +--! pin_search_path pass leaves it unpinned (no `SET search_path`), preserving +--! SQL-function inlining. It takes a bare `jsonb` arg (not a jsonb-backed +--! encrypted DOMAIN), so the structural skip in tasks/pin_search_path_v3.sql does +--! not recognise it; this marker is the documented manual opt-in. +COMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(jsonb) IS + 'eql-inline-critical: per-encrypted-value ORE helper; must stay inlinable (unpinned search_path)'; + + +--! @brief Extract ORE block index term from JSONB payload +--! @param val jsonb containing encrypted EQL payload +--! @return eql_v3_internal.ore_block_256 ORE block index term +--! @throws Exception if 'ob' field is missing +CREATE FUNCTION eql_v3_internal.ore_block_256(val jsonb) + RETURNS eql_v3_internal.ore_block_256 + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + BEGIN + -- Declared STRICT: PostgreSQL returns NULL for a NULL argument without + -- entering the body, so no explicit `val IS NULL` guard is needed. + IF eql_v3_internal.has_ore_block_256(val) THEN + RETURN eql_v3_internal.jsonb_array_to_ore_block_256(val->'ob'); + END IF; + RAISE 'Expected an ore index (ob) value in json: %', val; + END; +$$ LANGUAGE plpgsql; + + +--! @brief Check if JSONB payload contains an ORE block index term +--! @param val jsonb containing encrypted EQL payload +--! @return boolean True only if the 'ob' field is present and is a JSON array +--! @note A well-formed ORE index term is always a JSON array of block terms, so +--! this guard treats a present-but-non-array `ob` (a scalar or object) as +--! absent. That makes the extractor `ore_block_256(val)` RAISE on a +--! structurally invalid `ob` payload at the boundary instead of silently +--! degrading it to a NULL index term in `jsonb_array_to_ore_block_256`. The +--! previous `val ->> 'ob' IS NOT NULL` form stringified scalars/objects and so +--! reported them as present. `{}` (absent `ob`) and `{"ob": null}` (JSON null) +--! both remain `false`. +CREATE FUNCTION eql_v3_internal.has_ore_block_256(val jsonb) + RETURNS boolean + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + BEGIN + RETURN COALESCE(jsonb_typeof(val -> 'ob') = 'array', false); + END; +$$ LANGUAGE plpgsql; + + +--! @brief Compare two ORE block terms using cryptographic comparison +--! @internal +--! @param a eql_v3_internal.ore_block_256_term First ORE term +--! @param b eql_v3_internal.ore_block_256_term Second ORE term +--! @return integer -1 if a < b, 0 if a = b, 1 if a > b +--! @throws Exception if ciphertexts are different lengths +--! @note Marked `IMMUTABLE` (the three `compare_ore_block_256_term(s)` +--! overloads all are). This deliberately diverges from the v2 originals, +--! which carry no volatility marker and so default to `VOLATILE`. The +--! comparison is deterministic — its only crypto call, pgcrypto `encrypt()`, +--! is itself `IMMUTABLE STRICT PARALLEL SAFE` — so `IMMUTABLE` lets the +--! planner fold/cache these in ordering and index contexts. NOT `STRICT`: +--! the NULL-handling branches below are load-bearing for the array overload. +CREATE FUNCTION eql_v3_internal.compare_ore_block_256_term(a eql_v3_internal.ore_block_256_term, b eql_v3_internal.ore_block_256_term) + RETURNS integer + IMMUTABLE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + eq boolean := true; + unequal_block smallint := 0; + hash_key bytea; + data_block bytea; + encrypt_block bytea; + target_block bytea; + + left_block_size CONSTANT smallint := 16; + right_block_size CONSTANT smallint := 32; + + -- Block count N is DERIVED from the ciphertext length, not hardcoded to 8. + -- Wire format per term: + -- [ N PRP bytes ][ N*16B left blocks ][ 16B hash key ][ N*32B right blocks ] + -- octet_length = 17*N + 16 + 32*N = 49*N + 16 => N = (octet_length - 16) / 49 + -- This serves integer (N=8, 408B), timestamp (N=12, 604B), and numeric + -- (N=14, 702B) with one comparator. + n integer; + left_offset integer; -- ordinal offset of the first left block (1 + N PRP bytes) + right_offset integer; -- ordinal start of the right CT (= total left CT length = 17*N) + + indicator smallint := 0; + BEGIN + IF a IS NULL AND b IS NULL THEN + RETURN 0; + END IF; + + IF a IS NULL THEN + RETURN -1; + END IF; + + IF b IS NULL THEN + RETURN 1; + END IF; + + IF bit_length(a.bytes) != bit_length(b.bytes) THEN + RAISE EXCEPTION 'Ciphertexts are different lengths'; + END IF; + + -- Well-formedness: length must be exactly 49*N + 16 for some N >= 1. The + -- modulo alone is insufficient -- a 16-byte term passes (16 - 16) % 49 = 0 + -- and derives N = 0, which would fall through to the all-blocks-equal path + -- and return 0 instead of raising. The `<= 16` clause is load-bearing. + IF octet_length(a.bytes) <= 16 OR (octet_length(a.bytes) - 16) % 49 != 0 THEN + RAISE EXCEPTION 'Malformed ORE term: % bytes', octet_length(a.bytes); + END IF; + + n := (octet_length(a.bytes) - 16) / 49; + left_offset := 1 + n; -- left blocks begin right after the N PRP bytes + right_offset := 17 * n; -- right CT begins right after the 17*N-byte left CT + + FOR block IN 0..n-1 LOOP + -- Compare each PRP byte (the first N bytes) and its 16-byte left block. + IF + substr(a.bytes, 1 + block, 1) != substr(b.bytes, 1 + block, 1) + OR substr(a.bytes, left_offset + left_block_size * block, left_block_size) != substr(b.bytes, left_offset + left_block_size * block, left_block_size) + THEN + IF eq THEN + unequal_block := block; + END IF; + eq = false; + END IF; + END LOOP; + + IF eq THEN + RETURN 0::integer; + END IF; + + -- Hash key is the IV from the right CT of b. + hash_key := substr(b.bytes, right_offset + 1, 16); + + -- First right block is at right_offset + nonce_size (ordinally indexed). + target_block := substr(b.bytes, right_offset + 17 + (unequal_block * right_block_size), right_block_size); + + data_block := substr(a.bytes, left_offset + (left_block_size * unequal_block), left_block_size); + + encrypt_block := encrypt(data_block::bytea, hash_key::bytea, 'aes-ecb'); + + indicator := ( + get_bit( + encrypt_block, + 0 + ) + get_bit(target_block, get_byte(a.bytes, unequal_block))) % 2; + + IF indicator = 1 THEN + RETURN 1::integer; + ELSE + RETURN -1::integer; + END IF; + END; +$$ LANGUAGE plpgsql; + + +--! @brief Compare arrays of ORE block terms recursively +--! @internal +--! @param a eql_v3_internal.ore_block_256_term[] First array +--! @param b eql_v3_internal.ore_block_256_term[] Second array +--! @return integer -1/0/1, or NULL if either array is NULL +CREATE FUNCTION eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256_term[], b eql_v3_internal.ore_block_256_term[]) +RETURNS integer + IMMUTABLE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + cmp_result integer; + BEGIN + IF a IS NULL OR b IS NULL THEN + RETURN NULL; + END IF; + + IF cardinality(a) = 0 AND cardinality(b) = 0 THEN + RETURN 0; + END IF; + + IF (cardinality(a) = 0) AND cardinality(b) > 0 THEN + RETURN -1; + END IF; + + IF cardinality(a) > 0 AND (cardinality(b) = 0) THEN + RETURN 1; + END IF; + + cmp_result := eql_v3_internal.compare_ore_block_256_term(a[1], b[1]); + + IF cmp_result = 0 THEN + RETURN eql_v3_internal.compare_ore_block_256_terms(a[2:array_length(a,1)], b[2:array_length(b,1)]); + END IF; + + RETURN cmp_result; + END +$$ LANGUAGE plpgsql; + + +--! @brief Compare ORE block composite types +--! @internal +--! @param a eql_v3_internal.ore_block_256 First ORE block +--! @param b eql_v3_internal.ore_block_256 Second ORE block +--! @return integer -1/0/1 +CREATE FUNCTION eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) +RETURNS integer + IMMUTABLE + SET search_path = pg_catalog, extensions, public +AS $$ + BEGIN + RETURN eql_v3_internal.compare_ore_block_256_terms(a.terms, b.terms); + 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_ope_term(col)` engages structurally for the `_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[]; + +--! @file v3/sem/ore_cllw/types.sql +--! @brief CLLW ORE index term type for STE-vec range queries (eql_v3 SEM) +--! +--! Composite type for CLLW (Copyless Logarithmic Width) Order-Revealing +--! Encryption. The ciphertext is stored in the `oc` field of encrypted data +--! payloads (Standard-mode `ste_vec` elements). Used by the range operators +--! (`<`, `<=`, `>`, `>=`) when an sv element carries an `oc` term. +--! +--! The wire-format `oc` value is a hex string with a leading domain-tag byte +--! (`0x00` numeric, `0x01` string) followed by the CLLW ciphertext. The +--! decoded `bytes` field carries the full byte string including the tag — the +--! comparator is variable-length capable, so numeric and string values within +--! the same column order correctly: the domain tag separates the ranges +--! (numeric < string) and the within-domain comparison falls through to the +--! CLLW per-byte protocol. +--! +--! @note This is a transient type used only during query execution. +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE TYPE eql_v3_internal.ore_cllw AS ( + bytes bytea +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/timestamp/timestamp_types.sql +--! @brief Encrypted-domain types for timestamp. + +DO $$ +BEGIN + --! @brief Encrypted domain eql_v3.timestamp. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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; + + --! @brief Encrypted domain eql_v3.timestamp_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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; + + --! @brief Encrypted domain eql_v3.timestamp_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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; + + --! @brief Encrypted domain eql_v3.timestamp_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.timestamp_ord 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; + + --! @brief Encrypted domain eql_v3.timestamp_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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; +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/<T>/. +--! 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.<T>*) +--! @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.<T>*) +--! @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.<T>*) +--! @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. +--! +--! The six backing functions are inlinable single-statement SQL so the planner +--! can fold the eql_v3 comparison wrappers through to functional-index matching. + +--! @brief Equality backing function for ORE block types +--! @internal +--! +--! @param a eql_v3_internal.ore_block_256 Left operand +--! @param b eql_v3_internal.ore_block_256 Right operand +--! @return boolean True if the ORE blocks are equal +--! +--! @see eql_v3_internal.compare_ore_block_256_terms +CREATE FUNCTION eql_v3_internal.ore_block_256_eq(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) +RETURNS boolean + LANGUAGE sql + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = 0 +$$; + +--! @brief Not-equal backing function for ORE block types +--! @internal +--! +--! @param a eql_v3_internal.ore_block_256 Left operand +--! @param b eql_v3_internal.ore_block_256 Right operand +--! @return boolean True if the ORE blocks are not equal +--! +--! @see eql_v3_internal.compare_ore_block_256_terms +CREATE FUNCTION eql_v3_internal.ore_block_256_neq(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) +RETURNS boolean + LANGUAGE sql + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) <> 0 +$$; + +--! @brief Less-than backing function for ORE block types +--! @internal +--! +--! @param a eql_v3_internal.ore_block_256 Left operand +--! @param b eql_v3_internal.ore_block_256 Right operand +--! @return boolean True if the left operand is less than the right operand +--! +--! @see eql_v3_internal.compare_ore_block_256_terms +CREATE FUNCTION eql_v3_internal.ore_block_256_lt(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) +RETURNS boolean + LANGUAGE sql + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = -1 +$$; + +--! @brief Less-than-or-equal backing function for ORE block types +--! @internal +--! +--! @param a eql_v3_internal.ore_block_256 Left operand +--! @param b eql_v3_internal.ore_block_256 Right operand +--! @return boolean True if the left operand is less than or equal to the right operand +--! +--! @see eql_v3_internal.compare_ore_block_256_terms +CREATE FUNCTION eql_v3_internal.ore_block_256_lte(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) +RETURNS boolean + LANGUAGE sql + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) != 1 +$$; + +--! @brief Greater-than backing function for ORE block types +--! @internal +--! +--! @param a eql_v3_internal.ore_block_256 Left operand +--! @param b eql_v3_internal.ore_block_256 Right operand +--! @return boolean True if the left operand is greater than the right operand +--! +--! @see eql_v3_internal.compare_ore_block_256_terms +CREATE FUNCTION eql_v3_internal.ore_block_256_gt(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) +RETURNS boolean + LANGUAGE sql + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = 1 +$$; + +--! @brief Greater-than-or-equal backing function for ORE block types +--! @internal +--! +--! @param a eql_v3_internal.ore_block_256 Left operand +--! @param b eql_v3_internal.ore_block_256 Right operand +--! @return boolean True if the left operand is greater than or equal to the right operand +--! +--! @see eql_v3_internal.compare_ore_block_256_terms +CREATE FUNCTION eql_v3_internal.ore_block_256_gte(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) +RETURNS boolean + LANGUAGE sql + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) != -1 +$$; + + +--! @brief = operator for ORE block types +--! +--! COMMUTATOR is the operator itself: equality is symmetric. Required for the +--! MERGES flag — without it the planner raises "could not find commutator" the +--! first time an ore_block equality is used as a join qual (e.g. via the inlined +--! eql_v3_internal.<T>_ord_ore equality wrappers). +CREATE OPERATOR public.= ( + FUNCTION=eql_v3_internal.ore_block_256_eq, + LEFTARG=eql_v3_internal.ore_block_256, + RIGHTARG=eql_v3_internal.ore_block_256, + COMMUTATOR = OPERATOR(public.=), + NEGATOR = OPERATOR(public.<>), + RESTRICT = eqsel, + JOIN = eqjoinsel, + HASHES, + MERGES +); + +--! @brief <> operator for ORE block types +CREATE OPERATOR public.<> ( + FUNCTION=eql_v3_internal.ore_block_256_neq, + LEFTARG=eql_v3_internal.ore_block_256, + RIGHTARG=eql_v3_internal.ore_block_256, + COMMUTATOR = OPERATOR(public.<>), + NEGATOR = OPERATOR(public.=), + RESTRICT = neqsel, + JOIN = neqjoinsel, + MERGES +); + +--! @brief > operator for ORE block types +CREATE OPERATOR public.> ( + FUNCTION=eql_v3_internal.ore_block_256_gt, + LEFTARG=eql_v3_internal.ore_block_256, + RIGHTARG=eql_v3_internal.ore_block_256, + COMMUTATOR = OPERATOR(public.<), + NEGATOR = OPERATOR(public.<=), + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel +); + +--! @brief < operator for ORE block types +CREATE OPERATOR public.< ( + FUNCTION=eql_v3_internal.ore_block_256_lt, + LEFTARG=eql_v3_internal.ore_block_256, + RIGHTARG=eql_v3_internal.ore_block_256, + COMMUTATOR = OPERATOR(public.>), + NEGATOR = OPERATOR(public.>=), + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel +); + +--! @brief <= operator for ORE block types +CREATE OPERATOR public.<= ( + FUNCTION=eql_v3_internal.ore_block_256_lte, + LEFTARG=eql_v3_internal.ore_block_256, + RIGHTARG=eql_v3_internal.ore_block_256, + COMMUTATOR = OPERATOR(public.>=), + NEGATOR = OPERATOR(public.>), + RESTRICT = scalarlesel, + JOIN = scalarlejoinsel +); + +--! @brief >= operator for ORE block types +CREATE OPERATOR public.>= ( + FUNCTION=eql_v3_internal.ore_block_256_gte, + LEFTARG=eql_v3_internal.ore_block_256, + RIGHTARG=eql_v3_internal.ore_block_256, + COMMUTATOR = OPERATOR(public.<=), + NEGATOR = 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_ope_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)'; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/text/text_types.sql +--! @brief Encrypted-domain types for text. + +DO $$ +BEGIN + --! @brief Encrypted domain eql_v3.text. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.text AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + --! @brief Encrypted domain eql_v3.text_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.text_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; + + --! @brief Encrypted domain eql_v3.text_match. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_match' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.text_match AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'bf' + AND VALUE->>'v' = '3' + ); + END IF; + + --! @brief Encrypted domain eql_v3.text_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.text_ord_ore 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->>'v' = '3' + ); + END IF; + + --! @brief Encrypted domain eql_v3.text_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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 ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + --! @brief Encrypted domain eql_v3.text_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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; + + --! @brief Encrypted domain eql_v3.text_search. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_search' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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 ? 'ob' + AND VALUE ? 'bf' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; +END +$$; + +--! @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 +$$; + +--! @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 v3/scalars/smallint/smallint_types.sql +--! @brief Encrypted-domain types for smallint. + +DO $$ +BEGIN + --! @brief Encrypted domain eql_v3.smallint. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.smallint AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + --! @brief Encrypted domain eql_v3.smallint_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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; + + --! @brief Encrypted domain eql_v3.smallint_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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 jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + --! @brief Encrypted domain eql_v3.smallint_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.smallint_ord 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; + + --! @brief Encrypted domain eql_v3.smallint_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.smallint_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; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/real/real_types.sql +--! @brief Encrypted-domain types for real. + +DO $$ +BEGIN + --! @brief Encrypted domain eql_v3.real. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.real AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + --! @brief Encrypted domain eql_v3.real_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.real_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; + + --! @brief Encrypted domain eql_v3.real_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.real_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; + + --! @brief Encrypted domain eql_v3.real_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.real_ord 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; + + --! @brief Encrypted domain eql_v3.real_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.real_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; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/numeric/numeric_types.sql +--! @brief Encrypted-domain types for numeric. + +DO $$ +BEGIN + --! @brief Encrypted domain eql_v3.numeric. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.numeric AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + --! @brief Encrypted domain eql_v3.numeric_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.numeric_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; + + --! @brief Encrypted domain eql_v3.numeric_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.numeric_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; + + --! @brief Encrypted domain eql_v3.numeric_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.numeric_ord 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; + + --! @brief Encrypted domain eql_v3.numeric_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.numeric_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; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/integer/integer_types.sql +--! @brief Encrypted-domain types for integer. + +DO $$ +BEGIN + --! @brief Encrypted domain eql_v3.integer. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.integer AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + --! @brief Encrypted domain eql_v3.integer_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.integer_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; + + --! @brief Encrypted domain eql_v3.integer_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.integer_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; + + --! @brief Encrypted domain eql_v3.integer_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.integer_ord 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; + + --! @brief Encrypted domain eql_v3.integer_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.integer_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; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/double/double_types.sql +--! @brief Encrypted-domain types for double. + +DO $$ +BEGIN + --! @brief Encrypted domain eql_v3.double. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.double AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + --! @brief Encrypted domain eql_v3.double_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.double_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; + + --! @brief Encrypted domain eql_v3.double_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.double_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; + + --! @brief Encrypted domain eql_v3.double_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.double_ord 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; + + --! @brief Encrypted domain eql_v3.double_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.double_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; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/date/date_types.sql +--! @brief Encrypted-domain types for date. + +DO $$ +BEGIN + --! @brief Encrypted domain eql_v3.date. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.date AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + --! @brief Encrypted domain eql_v3.date_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.date_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; + + --! @brief Encrypted domain eql_v3.date_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.date_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; + + --! @brief Encrypted domain eql_v3.date_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.date_ord 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; + + --! @brief Encrypted domain eql_v3.date_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.date_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; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/bigint/bigint_types.sql +--! @brief Encrypted-domain types for bigint. + +DO $$ +BEGIN + --! @brief Encrypted domain eql_v3.bigint. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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 Encrypted domain eql_v3.bigint_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint_eq' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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; + + --! @brief Encrypted domain eql_v3.bigint_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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; + + --! @brief Encrypted domain eql_v3.bigint_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint_ord' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN eql_v3.bigint_ord 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; + + --! @brief Encrypted domain eql_v3.bigint_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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; +END +$$; + +--! @file v3/sem/ore_cllw/functions.sql +--! @brief CLLW ORE index-term extraction and comparison (eql_v3 SEM). + +--! @brief Extract CLLW ORE index term from raw jsonb +--! +--! Returns the CLLW ORE ciphertext from the `oc` field of a single sv element +--! supplied as raw jsonb. Inlinable single-statement SQL — the planner folds +--! the body into the calling query. +--! +--! **Missing-`oc` semantics**: returns SQL-level NULL (not a composite with +--! NULL bytes) when `oc` is absent, so btree's NULL handling filters those +--! rows from range queries. +--! +--! @param val jsonb An object carrying an `oc` field +--! @return eql_v3_internal.ore_cllw Composite carrying the CLLW ciphertext, or NULL +--! when the `oc` field is absent. +--! @see eql_v3_internal.has_ore_cllw +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.ore_cllw(val jsonb) + RETURNS eql_v3_internal.ore_cllw + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT CASE WHEN val ->> 'oc' IS NULL THEN NULL + ELSE ROW(decode(val ->> 'oc', 'hex'))::eql_v3_internal.ore_cllw + END +$$; + +COMMENT ON FUNCTION eql_v3_internal.ore_cllw(jsonb) IS + 'eql-inline-critical: raw-jsonb CLLW extractor; must stay inlinable (unpinned search_path)'; + +--! @brief Check if a raw jsonb value contains a CLLW ORE index term +--! @param val jsonb An object that may carry an `oc` field +--! @return boolean True if `oc` field is present and non-null +CREATE FUNCTION eql_v3_internal.has_ore_cllw(val jsonb) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT val ->> 'oc' IS NOT NULL +$$; + +COMMENT ON FUNCTION eql_v3_internal.has_ore_cllw(jsonb) IS + 'eql-inline-critical: raw-jsonb CLLW presence helper; must stay inlinable (unpinned search_path)'; + +--! @brief CLLW per-byte comparison helper +--! @internal +--! +--! Byte-by-byte comparison implementing the CLLW order-revealing protocol. +--! Identify the index of the first differing byte; if `(y_byte + 1) == x_byte` +--! (mod 256) there, then x > y; otherwise x < y. Equal inputs return 0. Inputs +--! MUST be the same length (the caller guarantees this). Stays `LANGUAGE +--! plpgsql` — the per-byte loop can't be a single inlinable SQL expression. +--! +--! @param a bytea First CLLW ciphertext slice +--! @param b bytea Second CLLW ciphertext slice +--! @return integer -1, 0, or 1 +--! @throws Exception if inputs are different lengths +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.compare_ore_cllw_term_bytes(a bytea, b bytea) +RETURNS int + SET search_path = pg_catalog, extensions, public +AS $$ +DECLARE + len_a INT; + len_b INT; + i INT; + first_diff INT := 0; +BEGIN + + len_a := LENGTH(a); + len_b := LENGTH(b); + + IF len_a != len_b THEN + RAISE EXCEPTION 'ore_cllw index terms are not the same length'; + END IF; + + FOR i IN 1..len_a LOOP + IF first_diff = 0 AND get_byte(a, i - 1) != get_byte(b, i - 1) THEN + first_diff := i; + END IF; + END LOOP; + + IF first_diff = 0 THEN + RETURN 0; + END IF; + + IF ((get_byte(b, first_diff - 1) + 1) & 255) = get_byte(a, first_diff - 1) THEN + RETURN 1; + ELSE + RETURN -1; + END IF; +END; +$$ LANGUAGE plpgsql; + +--! @brief Variable-length CLLW ORE term comparison +--! @internal +--! +--! Three-way comparison of two CLLW ORE ciphertext terms of potentially +--! different lengths. Compares the shared prefix via the CLLW per-byte +--! protocol; on equal prefixes, the shorter input sorts first. The leading +--! domain-tag byte makes numeric (`0x00`) sort before string (`0x01`). Stays +--! `LANGUAGE plpgsql` because it dispatches to `compare_ore_cllw_term_bytes`. +--! +--! btree filters NULL composites at the row level, so this should never see a +--! NULL composite under normal operation; the IS-NULL guard returns NULL +--! defensively. A non-NULL composite with NULL `bytes` is a contract violation +--! — the extractor returns SQL NULL (not ROW(NULL)) on missing `oc`, so raise +--! loudly rather than silently misorder. +--! +--! @param a eql_v3_internal.ore_cllw First term +--! @param b eql_v3_internal.ore_cllw Second term +--! @return integer -1, 0, or 1; NULL if either composite is NULL +--! @throws Exception if either composite has a NULL `bytes` field +--! @see eql_v3_internal.compare_ore_cllw_term_bytes +CREATE FUNCTION eql_v3_internal.compare_ore_cllw_term(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) +RETURNS int + SET search_path = pg_catalog, extensions, public +AS $$ +DECLARE + len_a INT; + len_b INT; + common_len INT; + cmp_result INT; +BEGIN + -- The `::text` cast is load-bearing, not a stylistic choice. For the + -- single-field `ore_cllw` composite, `ROW(NULL)::ore_cllw IS NULL` is TRUE + -- but `(ROW(NULL)::ore_cllw)::text IS NULL` is FALSE. Casting to text first + -- means a NULL-component composite falls THROUGH to the RAISE below (the + -- extractor-invariant violation) instead of silently returning NULL and + -- masking it. A plain `a IS NULL` would reintroduce that masking bug. + IF a::text IS NULL OR b::text IS NULL THEN + RETURN NULL; + END IF; + + IF a.bytes IS NULL OR b.bytes IS NULL THEN + RAISE EXCEPTION 'eql_v3_internal.compare_ore_cllw_term: composite has NULL bytes field — extractor invariant violated. Check that the index expression uses eql_v3_internal.ore_cllw(...) and not a hand-crafted ROW(NULL).'; + END IF; + + len_a := LENGTH(a.bytes); + len_b := LENGTH(b.bytes); + + IF len_a = 0 AND len_b = 0 THEN + RETURN 0; + ELSIF len_a = 0 THEN + RETURN -1; + ELSIF len_b = 0 THEN + RETURN 1; + END IF; + + IF len_a < len_b THEN + common_len := len_a; + ELSE + common_len := len_b; + END IF; + + cmp_result := eql_v3_internal.compare_ore_cllw_term_bytes( + SUBSTRING(a.bytes FROM 1 FOR common_len), + SUBSTRING(b.bytes FROM 1 FOR common_len) + ); + + IF cmp_result = -1 THEN + RETURN -1; + ELSIF cmp_result = 1 THEN + RETURN 1; + END IF; + + IF len_a < len_b THEN + RETURN -1; + ELSIF len_a > len_b THEN + RETURN 1; + ELSE + RETURN 0; + END IF; +END; +$$ LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ore_functions.sql +--! @brief Functions for eql_v3.timestamp_ord_ore. + +--! @brief Index extractor for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a 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) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.timestamp_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.timestamp_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.timestamp_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.timestamp_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.timestamp_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.timestamp_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ore. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param selector text +--! @return eql_v3.timestamp_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_ord_ore, selector text) +RETURNS eql_v3.timestamp_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param selector integer +--! @return eql_v3.timestamp_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_ord_ore, selector integer) +RETURNS eql_v3.timestamp_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.timestamp_ord_ore +--! @return eql_v3.timestamp_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.timestamp_ord_ore) +RETURNS eql_v3.timestamp_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.timestamp_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.timestamp_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.timestamp_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.timestamp_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.timestamp_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.timestamp_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.timestamp_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.timestamp_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.timestamp_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.timestamp_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b eql_v3.timestamp_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_ord_ore, b eql_v3.timestamp_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a eql_v3.timestamp_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ore. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.timestamp_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ope_functions.sql +--! @brief Functions for eql_v3.timestamp_ord_ope. + +--! @brief Index extractor for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a 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 eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.timestamp_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.timestamp_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.timestamp_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.timestamp_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.timestamp_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.timestamp_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.timestamp_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.timestamp_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.timestamp_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.timestamp_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.timestamp_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord_ope. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.timestamp_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.timestamp_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.timestamp_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param selector text +--! @return eql_v3.timestamp_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_ord_ope, selector text) +RETURNS eql_v3.timestamp_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param selector integer +--! @return eql_v3.timestamp_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_ord_ope, selector integer) +RETURNS eql_v3.timestamp_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.timestamp_ord_ope +--! @return eql_v3.timestamp_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.timestamp_ord_ope) +RETURNS eql_v3.timestamp_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.timestamp_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.timestamp_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.timestamp_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.timestamp_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.timestamp_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.timestamp_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.timestamp_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.timestamp_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.timestamp_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.timestamp_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b eql_v3.timestamp_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_ord_ope, b eql_v3.timestamp_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a eql_v3.timestamp_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord_ope. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.timestamp_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_functions.sql +--! @brief Functions for eql_v3.timestamp_ord. + +--! @brief Index extractor for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.timestamp_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_ord, b 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 eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.timestamp_ord) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_ord, b 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 eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.timestamp_ord) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.timestamp_ord, b 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 eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a 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::eql_v3.timestamp_ord) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.timestamp_ord, b 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 eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a 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::eql_v3.timestamp_ord) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.timestamp_ord, b 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 eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a 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::eql_v3.timestamp_ord) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.timestamp_ord, b 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 eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a 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::eql_v3.timestamp_ord) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_ord. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.timestamp_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param selector text +--! @return eql_v3.timestamp_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_ord, selector text) +RETURNS eql_v3.timestamp_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param selector integer +--! @return eql_v3.timestamp_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_ord, selector integer) +RETURNS eql_v3.timestamp_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a jsonb +--! @param selector eql_v3.timestamp_ord +--! @return eql_v3.timestamp_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.timestamp_ord) +RETURNS eql_v3.timestamp_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a jsonb +--! @param selector eql_v3.timestamp_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.timestamp_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.timestamp_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.timestamp_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.timestamp_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.timestamp_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.timestamp_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.timestamp_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.timestamp_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.timestamp_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b eql_v3.timestamp_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_ord, b eql_v3.timestamp_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a eql_v3.timestamp_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_ord. +--! @param a jsonb +--! @param b eql_v3.timestamp_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.timestamp_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_search_functions.sql +--! @brief Functions for eql_v3.text_search. + +--! @brief Index extractor for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a 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) $$; + +--! @brief Index extractor for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.text_search) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Index extractor for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @return eql_v3_internal.bloom_filter +CREATE FUNCTION eql_v3.match_term(a 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.text_search. +--! @param a eql_v3.text_search +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.text_search, b 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.text_search. +--! @param a eql_v3.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.text_search) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a jsonb +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_search) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.text_search, b 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.text_search. +--! @param a eql_v3.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.text_search) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a jsonb +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_search) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.text_search, b eql_v3.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.text_search. +--! @param a eql_v3.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a 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::eql_v3.text_search) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a jsonb +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_search) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.text_search, b eql_v3.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.text_search. +--! @param a eql_v3.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a 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::eql_v3.text_search) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a jsonb +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_search) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.text_search, b eql_v3.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.text_search. +--! @param a eql_v3.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a 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::eql_v3.text_search) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a jsonb +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_search) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.text_search, b eql_v3.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.text_search. +--! @param a eql_v3.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a 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::eql_v3.text_search) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a jsonb +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_search) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.text_search, b 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.text_search. +--! @param a eql_v3.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(a 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::eql_v3.text_search) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a jsonb +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::eql_v3.text_search) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.text_search, b 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.text_search. +--! @param a eql_v3.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a 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::eql_v3.text_search) $$; + +--! @brief Operator wrapper for eql_v3.text_search. +--! @param a jsonb +--! @param b eql_v3.text_search +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::eql_v3.text_search) <@ eql_v3.match_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param selector text +--! @return eql_v3.text_search +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_search, selector text) +RETURNS eql_v3.text_search IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param selector integer +--! @return eql_v3.text_search +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_search, selector integer) +RETURNS eql_v3.text_search IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a jsonb +--! @param selector eql_v3.text_search +--! @return eql_v3.text_search +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text_search) +RETURNS eql_v3.text_search IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_search, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_search, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a jsonb +--! @param selector eql_v3.text_search +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text_search) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text_search, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text_search, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text_search, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text_search, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text_search, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text_search, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text_search, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_search, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_search, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_search, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text_search, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b eql_v3.text_search +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_search, b eql_v3.text_search) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a eql_v3.text_search +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_search, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_search. +--! @param a jsonb +--! @param b eql_v3.text_search +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text_search) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_search'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ore_functions.sql +--! @brief Functions for eql_v3.text_ord_ore. + +--! @brief Index extractor for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a 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) $$; + +--! @brief Index extractor for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a 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) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.text_ord_ore, b 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.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.text_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord_ore) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.text_ord_ore, b 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.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.text_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord_ore) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.text_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.text_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.text_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.text_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param b eql_v3.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param selector text +--! @return eql_v3.text_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_ord_ore, selector text) +RETURNS eql_v3.text_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param selector integer +--! @return eql_v3.text_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_ord_ore, selector integer) +RETURNS eql_v3.text_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.text_ord_ore +--! @return eql_v3.text_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text_ord_ore) +RETURNS eql_v3.text_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.text_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b eql_v3.text_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_ord_ore, b eql_v3.text_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a eql_v3.text_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ore. +--! @param a jsonb +--! @param b eql_v3.text_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ope_functions.sql +--! @brief Functions for eql_v3.text_ord_ope. + +--! @brief Index extractor for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a 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 Index extractor for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a 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 Operator wrapper for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.text_ord_ope, b 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.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.text_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a jsonb +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord_ope) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.text_ord_ope, b 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.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.text_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a jsonb +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord_ope) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.text_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a jsonb +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.text_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.text_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a jsonb +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.text_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.text_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a jsonb +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.text_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.text_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.text_ord_ope. +--! @param a jsonb +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.text_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a jsonb +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.text_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a jsonb +--! @param b eql_v3.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.text_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param selector text +--! @return eql_v3.text_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_ord_ope, selector text) +RETURNS eql_v3.text_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param selector integer +--! @return eql_v3.text_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_ord_ope, selector integer) +RETURNS eql_v3.text_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.text_ord_ope +--! @return eql_v3.text_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text_ord_ope) +RETURNS eql_v3.text_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.text_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b eql_v3.text_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_ord_ope, b eql_v3.text_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a eql_v3.text_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord_ope. +--! @param a jsonb +--! @param b eql_v3.text_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_functions.sql +--! @brief Functions for eql_v3.text_ord. + +--! @brief Index extractor for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a 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) $$; + +--! @brief Index extractor for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.text_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.text_ord, b 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.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.text_ord) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a jsonb +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.text_ord, b 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.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.text_ord) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a jsonb +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_ord) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord, b 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.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.text_ord) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a jsonb +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord, b 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.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.text_ord) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a jsonb +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord, b 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.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.text_ord) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a jsonb +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord, b 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.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.text_ord) $$; + +--! @brief Operator wrapper for eql_v3.text_ord. +--! @param a jsonb +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.text_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_ord, b eql_v3.text_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a jsonb +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.text_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_ord, b eql_v3.text_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a jsonb +--! @param b eql_v3.text_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.text_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param selector text +--! @return eql_v3.text_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_ord, selector text) +RETURNS eql_v3.text_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param selector integer +--! @return eql_v3.text_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_ord, selector integer) +RETURNS eql_v3.text_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a jsonb +--! @param selector eql_v3.text_ord +--! @return eql_v3.text_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text_ord) +RETURNS eql_v3.text_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a jsonb +--! @param selector eql_v3.text_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b eql_v3.text_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_ord, b eql_v3.text_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a eql_v3.text_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_ord. +--! @param a jsonb +--! @param b eql_v3.text_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ore_functions.sql +--! @brief Functions for eql_v3.smallint_ord_ore. + +--! @brief Index extractor for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.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.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.smallint_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.smallint_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.smallint_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.smallint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.smallint_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.smallint_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.smallint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.smallint_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.smallint_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.smallint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.smallint_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.smallint_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.smallint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.smallint_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_ord_ore, b eql_v3.smallint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.smallint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_ord_ore, b eql_v3.smallint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.smallint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param selector text +--! @return eql_v3.smallint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_ord_ore, selector text) +RETURNS eql_v3.smallint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param selector integer +--! @return eql_v3.smallint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_ord_ore, selector integer) +RETURNS eql_v3.smallint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.smallint_ord_ore +--! @return eql_v3.smallint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.smallint_ord_ore) +RETURNS eql_v3.smallint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.smallint_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.smallint_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.smallint_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.smallint_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.smallint_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.smallint_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.smallint_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.smallint_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.smallint_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.smallint_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b eql_v3.smallint_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_ord_ore, b eql_v3.smallint_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a eql_v3.smallint_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.smallint_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ope_functions.sql +--! @brief Functions for eql_v3.smallint_ord_ope. + +--! @brief Index extractor for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a 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 eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.smallint_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.smallint_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.smallint_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.smallint_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.smallint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.smallint_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.smallint_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.smallint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.smallint_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.smallint_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.smallint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.smallint_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.smallint_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.smallint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.smallint_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.smallint_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.smallint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.smallint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param selector text +--! @return eql_v3.smallint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_ord_ope, selector text) +RETURNS eql_v3.smallint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param selector integer +--! @return eql_v3.smallint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_ord_ope, selector integer) +RETURNS eql_v3.smallint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.smallint_ord_ope +--! @return eql_v3.smallint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.smallint_ord_ope) +RETURNS eql_v3.smallint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.smallint_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.smallint_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.smallint_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.smallint_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.smallint_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.smallint_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.smallint_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.smallint_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.smallint_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.smallint_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b eql_v3.smallint_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_ord_ope, b eql_v3.smallint_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a eql_v3.smallint_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.smallint_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.smallint_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_functions.sql +--! @brief Functions for eql_v3.smallint_ord. + +--! @brief Index extractor for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.smallint_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_ord, b 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.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.smallint_ord) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord. +--! @param a jsonb +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_ord, b 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.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.smallint_ord) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord. +--! @param a jsonb +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.smallint_ord, b 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.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.smallint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.smallint_ord) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord. +--! @param a jsonb +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.smallint_ord, b 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.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.smallint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.smallint_ord) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord. +--! @param a jsonb +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.smallint_ord, b 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.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.smallint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.smallint_ord) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord. +--! @param a jsonb +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.smallint_ord, b 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.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.smallint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.smallint_ord) $$; + +--! @brief Operator wrapper for eql_v3.smallint_ord. +--! @param a jsonb +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.smallint_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_ord, b eql_v3.smallint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a jsonb +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.smallint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_ord, b eql_v3.smallint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a jsonb +--! @param b eql_v3.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.smallint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param selector text +--! @return eql_v3.smallint_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_ord, selector text) +RETURNS eql_v3.smallint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param selector integer +--! @return eql_v3.smallint_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_ord, selector integer) +RETURNS eql_v3.smallint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a jsonb +--! @param selector eql_v3.smallint_ord +--! @return eql_v3.smallint_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.smallint_ord) +RETURNS eql_v3.smallint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a jsonb +--! @param selector eql_v3.smallint_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.smallint_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.smallint_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.smallint_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.smallint_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.smallint_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.smallint_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.smallint_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.smallint_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.smallint_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b eql_v3.smallint_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_ord, b eql_v3.smallint_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a eql_v3.smallint_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_ord. +--! @param a jsonb +--! @param b eql_v3.smallint_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.smallint_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ore_functions.sql +--! @brief Functions for eql_v3.real_ord_ore. + +--! @brief Index extractor for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a 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 eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.real_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a jsonb +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.real_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a jsonb +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.real_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a jsonb +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.real_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a jsonb +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.real_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a jsonb +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.real_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ore. +--! @param a jsonb +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a jsonb +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.real_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a jsonb +--! @param b eql_v3.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.real_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param selector text +--! @return eql_v3.real_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_ord_ore, selector text) +RETURNS eql_v3.real_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param selector integer +--! @return eql_v3.real_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_ord_ore, selector integer) +RETURNS eql_v3.real_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.real_ord_ore +--! @return eql_v3.real_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.real_ord_ore) +RETURNS eql_v3.real_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.real_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.real_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.real_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.real_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.real_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.real_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.real_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.real_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.real_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.real_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b eql_v3.real_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_ord_ore, b eql_v3.real_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a eql_v3.real_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ore. +--! @param a jsonb +--! @param b eql_v3.real_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.real_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ope_functions.sql +--! @brief Functions for eql_v3.real_ord_ope. + +--! @brief Index extractor for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.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.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.real_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a jsonb +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.real_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.real_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a jsonb +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.real_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.real_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a jsonb +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.real_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.real_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a jsonb +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.real_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.real_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a jsonb +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.real_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.real_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.real_ord_ope. +--! @param a jsonb +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.real_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a jsonb +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.real_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a jsonb +--! @param b eql_v3.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.real_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param selector text +--! @return eql_v3.real_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_ord_ope, selector text) +RETURNS eql_v3.real_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param selector integer +--! @return eql_v3.real_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_ord_ope, selector integer) +RETURNS eql_v3.real_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.real_ord_ope +--! @return eql_v3.real_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.real_ord_ope) +RETURNS eql_v3.real_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.real_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.real_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.real_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.real_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.real_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.real_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.real_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.real_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.real_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.real_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b eql_v3.real_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_ord_ope, b eql_v3.real_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a eql_v3.real_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord_ope. +--! @param a jsonb +--! @param b eql_v3.real_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.real_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_functions.sql +--! @brief Functions for eql_v3.real_ord. + +--! @brief Index extractor for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.real_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.real_ord, b 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.real_ord. +--! @param a eql_v3.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.real_ord) $$; + +--! @brief Operator wrapper for eql_v3.real_ord. +--! @param a jsonb +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.real_ord, b 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.real_ord. +--! @param a eql_v3.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.real_ord) $$; + +--! @brief Operator wrapper for eql_v3.real_ord. +--! @param a jsonb +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.real_ord, b 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.real_ord. +--! @param a eql_v3.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a 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::eql_v3.real_ord) $$; + +--! @brief Operator wrapper for eql_v3.real_ord. +--! @param a jsonb +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.real_ord, b 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.real_ord. +--! @param a eql_v3.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a 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::eql_v3.real_ord) $$; + +--! @brief Operator wrapper for eql_v3.real_ord. +--! @param a jsonb +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.real_ord, b 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.real_ord. +--! @param a eql_v3.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a 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::eql_v3.real_ord) $$; + +--! @brief Operator wrapper for eql_v3.real_ord. +--! @param a jsonb +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.real_ord, b 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.real_ord. +--! @param a eql_v3.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a 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::eql_v3.real_ord) $$; + +--! @brief Operator wrapper for eql_v3.real_ord. +--! @param a jsonb +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.real_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_ord, b eql_v3.real_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a jsonb +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.real_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_ord, b eql_v3.real_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a jsonb +--! @param b eql_v3.real_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.real_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param selector text +--! @return eql_v3.real_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_ord, selector text) +RETURNS eql_v3.real_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param selector integer +--! @return eql_v3.real_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_ord, selector integer) +RETURNS eql_v3.real_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a jsonb +--! @param selector eql_v3.real_ord +--! @return eql_v3.real_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.real_ord) +RETURNS eql_v3.real_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a jsonb +--! @param selector eql_v3.real_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.real_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.real_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.real_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.real_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.real_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.real_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.real_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.real_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.real_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b eql_v3.real_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_ord, b eql_v3.real_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a eql_v3.real_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_ord. +--! @param a jsonb +--! @param b eql_v3.real_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.real_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ore_functions.sql +--! @brief Functions for eql_v3.numeric_ord_ore. + +--! @brief Index extractor for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a 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 eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.numeric_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.numeric_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.numeric_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a 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::eql_v3.numeric_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.numeric_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a 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::eql_v3.numeric_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.numeric_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a 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::eql_v3.numeric_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.numeric_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a 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::eql_v3.numeric_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.numeric_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.numeric_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param selector text +--! @return eql_v3.numeric_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_ord_ore, selector text) +RETURNS eql_v3.numeric_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param selector integer +--! @return eql_v3.numeric_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_ord_ore, selector integer) +RETURNS eql_v3.numeric_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.numeric_ord_ore +--! @return eql_v3.numeric_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.numeric_ord_ore) +RETURNS eql_v3.numeric_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.numeric_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.numeric_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.numeric_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.numeric_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.numeric_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.numeric_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.numeric_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.numeric_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.numeric_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.numeric_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b eql_v3.numeric_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_ord_ore, b eql_v3.numeric_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a eql_v3.numeric_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ore. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.numeric_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ope_functions.sql +--! @brief Functions for eql_v3.numeric_ord_ope. + +--! @brief Index extractor for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a 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 eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.numeric_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.numeric_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.numeric_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.numeric_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.numeric_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.numeric_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.numeric_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.numeric_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.numeric_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.numeric_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.numeric_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.numeric_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.numeric_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.numeric_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.numeric_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord_ope. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.numeric_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.numeric_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.numeric_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param selector text +--! @return eql_v3.numeric_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_ord_ope, selector text) +RETURNS eql_v3.numeric_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param selector integer +--! @return eql_v3.numeric_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_ord_ope, selector integer) +RETURNS eql_v3.numeric_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.numeric_ord_ope +--! @return eql_v3.numeric_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.numeric_ord_ope) +RETURNS eql_v3.numeric_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.numeric_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.numeric_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.numeric_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.numeric_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.numeric_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.numeric_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.numeric_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.numeric_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.numeric_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.numeric_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b eql_v3.numeric_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_ord_ope, b eql_v3.numeric_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a eql_v3.numeric_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord_ope. +--! @param a jsonb +--! @param b eql_v3.numeric_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.numeric_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_functions.sql +--! @brief Functions for eql_v3.numeric_ord. + +--! @brief Index extractor for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.numeric_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_ord, b 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.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.numeric_ord) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a jsonb +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_ord, b 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.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.numeric_ord) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a jsonb +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.numeric_ord, b 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.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a 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::eql_v3.numeric_ord) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a jsonb +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.numeric_ord, b 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.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a 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::eql_v3.numeric_ord) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a jsonb +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.numeric_ord, b 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.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a 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::eql_v3.numeric_ord) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a jsonb +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.numeric_ord, b 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.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a 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::eql_v3.numeric_ord) $$; + +--! @brief Operator wrapper for eql_v3.numeric_ord. +--! @param a jsonb +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.numeric_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_ord, b eql_v3.numeric_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a jsonb +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.numeric_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_ord, b eql_v3.numeric_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a jsonb +--! @param b eql_v3.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.numeric_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param selector text +--! @return eql_v3.numeric_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_ord, selector text) +RETURNS eql_v3.numeric_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param selector integer +--! @return eql_v3.numeric_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_ord, selector integer) +RETURNS eql_v3.numeric_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a jsonb +--! @param selector eql_v3.numeric_ord +--! @return eql_v3.numeric_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.numeric_ord) +RETURNS eql_v3.numeric_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a jsonb +--! @param selector eql_v3.numeric_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.numeric_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.numeric_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.numeric_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.numeric_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.numeric_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.numeric_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.numeric_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.numeric_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.numeric_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b eql_v3.numeric_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_ord, b eql_v3.numeric_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a eql_v3.numeric_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_ord. +--! @param a jsonb +--! @param b eql_v3.numeric_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.numeric_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ore_functions.sql +--! @brief Functions for eql_v3.integer_ord_ore. + +--! @brief Index extractor for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a 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 eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.integer_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.integer_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.integer_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.integer_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.integer_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.integer_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ore. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.integer_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.integer_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param selector text +--! @return eql_v3.integer_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_ord_ore, selector text) +RETURNS eql_v3.integer_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param selector integer +--! @return eql_v3.integer_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_ord_ore, selector integer) +RETURNS eql_v3.integer_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.integer_ord_ore +--! @return eql_v3.integer_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.integer_ord_ore) +RETURNS eql_v3.integer_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.integer_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.integer_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.integer_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.integer_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.integer_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.integer_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.integer_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.integer_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.integer_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.integer_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b eql_v3.integer_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_ord_ore, b eql_v3.integer_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a eql_v3.integer_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ore. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.integer_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ope_functions.sql +--! @brief Functions for eql_v3.integer_ord_ope. + +--! @brief Index extractor for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a 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 eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.integer_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.integer_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.integer_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.integer_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.integer_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.integer_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.integer_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.integer_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.integer_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.integer_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.integer_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.integer_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.integer_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.integer_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.integer_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.integer_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.integer_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord_ope. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.integer_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.integer_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.integer_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param selector text +--! @return eql_v3.integer_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_ord_ope, selector text) +RETURNS eql_v3.integer_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param selector integer +--! @return eql_v3.integer_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_ord_ope, selector integer) +RETURNS eql_v3.integer_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.integer_ord_ope +--! @return eql_v3.integer_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.integer_ord_ope) +RETURNS eql_v3.integer_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.integer_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.integer_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.integer_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.integer_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.integer_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.integer_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.integer_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.integer_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.integer_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.integer_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b eql_v3.integer_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_ord_ope, b eql_v3.integer_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a eql_v3.integer_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord_ope. +--! @param a jsonb +--! @param b eql_v3.integer_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.integer_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_functions.sql +--! @brief Functions for eql_v3.integer_ord. + +--! @brief Index extractor for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.integer_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.integer_ord, b 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.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.integer_ord) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord. +--! @param a jsonb +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.integer_ord, b 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.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.integer_ord) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord. +--! @param a jsonb +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.integer_ord, b 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.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a 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::eql_v3.integer_ord) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord. +--! @param a jsonb +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.integer_ord, b 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.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a 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::eql_v3.integer_ord) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord. +--! @param a jsonb +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.integer_ord, b 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.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a 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::eql_v3.integer_ord) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord. +--! @param a jsonb +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.integer_ord, b 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.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a 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::eql_v3.integer_ord) $$; + +--! @brief Operator wrapper for eql_v3.integer_ord. +--! @param a jsonb +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.integer_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_ord, b eql_v3.integer_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a jsonb +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.integer_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_ord, b eql_v3.integer_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a jsonb +--! @param b eql_v3.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.integer_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param selector text +--! @return eql_v3.integer_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_ord, selector text) +RETURNS eql_v3.integer_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param selector integer +--! @return eql_v3.integer_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_ord, selector integer) +RETURNS eql_v3.integer_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a jsonb +--! @param selector eql_v3.integer_ord +--! @return eql_v3.integer_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.integer_ord) +RETURNS eql_v3.integer_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a jsonb +--! @param selector eql_v3.integer_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.integer_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.integer_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.integer_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.integer_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.integer_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.integer_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.integer_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.integer_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.integer_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b eql_v3.integer_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_ord, b eql_v3.integer_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a eql_v3.integer_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_ord. +--! @param a jsonb +--! @param b eql_v3.integer_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.integer_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ore_functions.sql +--! @brief Functions for eql_v3.double_ord_ore. + +--! @brief Index extractor for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a 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 eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.double_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a jsonb +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.double_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a jsonb +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.double_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a jsonb +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.double_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a jsonb +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.double_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a jsonb +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.double_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ore. +--! @param a jsonb +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a jsonb +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.double_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a jsonb +--! @param b eql_v3.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.double_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param selector text +--! @return eql_v3.double_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_ord_ore, selector text) +RETURNS eql_v3.double_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param selector integer +--! @return eql_v3.double_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_ord_ore, selector integer) +RETURNS eql_v3.double_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.double_ord_ore +--! @return eql_v3.double_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.double_ord_ore) +RETURNS eql_v3.double_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.double_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.double_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.double_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.double_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.double_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.double_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.double_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.double_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.double_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.double_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b eql_v3.double_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_ord_ore, b eql_v3.double_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a eql_v3.double_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ore. +--! @param a jsonb +--! @param b eql_v3.double_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.double_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ope_functions.sql +--! @brief Functions for eql_v3.double_ord_ope. + +--! @brief Index extractor for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.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.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.double_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.double_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a jsonb +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.double_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.double_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.double_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a jsonb +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.double_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.double_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.double_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a jsonb +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.double_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.double_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.double_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a jsonb +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.double_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.double_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.double_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a jsonb +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.double_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.double_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.double_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.double_ord_ope. +--! @param a jsonb +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.double_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a jsonb +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.double_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a jsonb +--! @param b eql_v3.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.double_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param selector text +--! @return eql_v3.double_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_ord_ope, selector text) +RETURNS eql_v3.double_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param selector integer +--! @return eql_v3.double_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_ord_ope, selector integer) +RETURNS eql_v3.double_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.double_ord_ope +--! @return eql_v3.double_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.double_ord_ope) +RETURNS eql_v3.double_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.double_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.double_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.double_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.double_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.double_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.double_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.double_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.double_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.double_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.double_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b eql_v3.double_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_ord_ope, b eql_v3.double_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a eql_v3.double_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord_ope. +--! @param a jsonb +--! @param b eql_v3.double_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.double_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_functions.sql +--! @brief Functions for eql_v3.double_ord. + +--! @brief Index extractor for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.double_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.double_ord, b eql_v3.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.double_ord) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a jsonb +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.double_ord, b eql_v3.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.double_ord) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a jsonb +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.double_ord, b eql_v3.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.double_ord) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a jsonb +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.double_ord, b eql_v3.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.double_ord) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a jsonb +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.double_ord, b eql_v3.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.double_ord) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a jsonb +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.double_ord, b eql_v3.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.double_ord) $$; + +--! @brief Operator wrapper for eql_v3.double_ord. +--! @param a jsonb +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.double_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_ord, b eql_v3.double_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a jsonb +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.double_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_ord, b eql_v3.double_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a jsonb +--! @param b eql_v3.double_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.double_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param selector text +--! @return eql_v3.double_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_ord, selector text) +RETURNS eql_v3.double_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param selector integer +--! @return eql_v3.double_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_ord, selector integer) +RETURNS eql_v3.double_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a jsonb +--! @param selector eql_v3.double_ord +--! @return eql_v3.double_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.double_ord) +RETURNS eql_v3.double_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a jsonb +--! @param selector eql_v3.double_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.double_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.double_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.double_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.double_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.double_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.double_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.double_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.double_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.double_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b eql_v3.double_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_ord, b eql_v3.double_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a eql_v3.double_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_ord. +--! @param a jsonb +--! @param b eql_v3.double_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.double_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ore_functions.sql +--! @brief Functions for eql_v3.date_ord_ore. + +--! @brief Index extractor for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a 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 eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.date_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.date_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.date_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.date_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.date_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a 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::eql_v3.date_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.date_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a 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::eql_v3.date_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.date_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a 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::eql_v3.date_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.date_ord_ore, b 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) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a 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::eql_v3.date_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.date_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param b eql_v3.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.date_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param selector text +--! @return eql_v3.date_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_ord_ore, selector text) +RETURNS eql_v3.date_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param selector integer +--! @return eql_v3.date_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_ord_ore, selector integer) +RETURNS eql_v3.date_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.date_ord_ore +--! @return eql_v3.date_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.date_ord_ore) +RETURNS eql_v3.date_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.date_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.date_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.date_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.date_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.date_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.date_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.date_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.date_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.date_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.date_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b eql_v3.date_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_ord_ore, b eql_v3.date_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a eql_v3.date_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ore. +--! @param a jsonb +--! @param b eql_v3.date_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.date_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ope_functions.sql +--! @brief Functions for eql_v3.date_ord_ope. + +--! @brief Index extractor for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a 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 eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.date_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.date_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a jsonb +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.date_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.date_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.date_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a jsonb +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.date_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.date_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.date_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a jsonb +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.date_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.date_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.date_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a jsonb +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.date_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.date_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.date_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a jsonb +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.date_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.date_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.date_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.date_ord_ope. +--! @param a jsonb +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.date_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a jsonb +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.date_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a jsonb +--! @param b eql_v3.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.date_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param selector text +--! @return eql_v3.date_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_ord_ope, selector text) +RETURNS eql_v3.date_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param selector integer +--! @return eql_v3.date_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_ord_ope, selector integer) +RETURNS eql_v3.date_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.date_ord_ope +--! @return eql_v3.date_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.date_ord_ope) +RETURNS eql_v3.date_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.date_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.date_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.date_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.date_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.date_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.date_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.date_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.date_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.date_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.date_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b eql_v3.date_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_ord_ope, b eql_v3.date_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a eql_v3.date_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord_ope. +--! @param a jsonb +--! @param b eql_v3.date_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.date_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_functions.sql +--! @brief Functions for eql_v3.date_ord. + +--! @brief Index extractor for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.date_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.date_ord, b 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.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.date_ord) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a jsonb +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.date_ord, b 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.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.date_ord) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a jsonb +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.date_ord, b 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.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a 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::eql_v3.date_ord) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a jsonb +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.date_ord, b 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.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a 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::eql_v3.date_ord) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a jsonb +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.date_ord, b 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.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a 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::eql_v3.date_ord) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a jsonb +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.date_ord, b 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.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a 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::eql_v3.date_ord) $$; + +--! @brief Operator wrapper for eql_v3.date_ord. +--! @param a jsonb +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.date_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_ord, b eql_v3.date_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a jsonb +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.date_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_ord, b eql_v3.date_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a jsonb +--! @param b eql_v3.date_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.date_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param selector text +--! @return eql_v3.date_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_ord, selector text) +RETURNS eql_v3.date_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param selector integer +--! @return eql_v3.date_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_ord, selector integer) +RETURNS eql_v3.date_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a jsonb +--! @param selector eql_v3.date_ord +--! @return eql_v3.date_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.date_ord) +RETURNS eql_v3.date_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a jsonb +--! @param selector eql_v3.date_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.date_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.date_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.date_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.date_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.date_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.date_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.date_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.date_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.date_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b eql_v3.date_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_ord, b eql_v3.date_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a eql_v3.date_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_ord. +--! @param a jsonb +--! @param b eql_v3.date_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.date_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/boolean/boolean_types.sql +--! @brief Encrypted-domain types for boolean. + +DO $$ +BEGIN + --! @brief Encrypted domain eql_v3.boolean. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'boolean' AND typnamespace = 'eql_v3'::regnamespace + ) THEN + CREATE DOMAIN 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; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ore_functions.sql +--! @brief Functions for eql_v3.bigint_ord_ore. + +--! @brief Index extractor for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a 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 Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::eql_v3.bigint_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::eql_v3.bigint_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.bigint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::eql_v3.bigint_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.bigint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::eql_v3.bigint_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.bigint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::eql_v3.bigint_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.bigint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::eql_v3.bigint_ord_ore) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param selector text +--! @return eql_v3.bigint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_ord_ore, selector text) +RETURNS eql_v3.bigint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param selector integer +--! @return eql_v3.bigint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_ord_ore, selector integer) +RETURNS eql_v3.bigint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.bigint_ord_ore +--! @return eql_v3.bigint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.bigint_ord_ore) +RETURNS eql_v3.bigint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a jsonb +--! @param selector eql_v3.bigint_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.bigint_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.bigint_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.bigint_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.bigint_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.bigint_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.bigint_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.bigint_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.bigint_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.bigint_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b eql_v3.bigint_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_ord_ore, b eql_v3.bigint_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a eql_v3.bigint_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ore. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.bigint_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ope_functions.sql +--! @brief Functions for eql_v3.bigint_ord_ope. + +--! @brief Index extractor for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a 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 eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::eql_v3.bigint_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.bigint_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::eql_v3.bigint_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.bigint_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::eql_v3.bigint_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.bigint_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::eql_v3.bigint_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.bigint_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::eql_v3.bigint_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.bigint_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::eql_v3.bigint_ord_ope) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::eql_v3.bigint_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.bigint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.bigint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param selector text +--! @return eql_v3.bigint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_ord_ope, selector text) +RETURNS eql_v3.bigint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param selector integer +--! @return eql_v3.bigint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_ord_ope, selector integer) +RETURNS eql_v3.bigint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.bigint_ord_ope +--! @return eql_v3.bigint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.bigint_ord_ope) +RETURNS eql_v3.bigint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a jsonb +--! @param selector eql_v3.bigint_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.bigint_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.bigint_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.bigint_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.bigint_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.bigint_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.bigint_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.bigint_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.bigint_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.bigint_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b eql_v3.bigint_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_ord_ope, b eql_v3.bigint_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a eql_v3.bigint_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord_ope. +--! @param a jsonb +--! @param b eql_v3.bigint_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.bigint_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_functions.sql +--! @brief Functions for eql_v3.bigint_ord. + +--! @brief Index extractor for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a eql_v3.bigint_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_ord, b 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 Operator wrapper for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.bigint_ord) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord. +--! @param a jsonb +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_ord, b 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 Operator wrapper for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.bigint_ord) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord. +--! @param a jsonb +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a eql_v3.bigint_ord, b 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 Operator wrapper for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a 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::eql_v3.bigint_ord) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord. +--! @param a jsonb +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b eql_v3.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a eql_v3.bigint_ord, b 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 Operator wrapper for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a 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::eql_v3.bigint_ord) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord. +--! @param a jsonb +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b eql_v3.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a eql_v3.bigint_ord, b 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 Operator wrapper for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a 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::eql_v3.bigint_ord) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord. +--! @param a jsonb +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b eql_v3.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a eql_v3.bigint_ord, b 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 Operator wrapper for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a 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::eql_v3.bigint_ord) $$; + +--! @brief Operator wrapper for eql_v3.bigint_ord. +--! @param a jsonb +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b eql_v3.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::eql_v3.bigint_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_ord, b eql_v3.bigint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a jsonb +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.bigint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_ord, b eql_v3.bigint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a jsonb +--! @param b eql_v3.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.bigint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param selector text +--! @return eql_v3.bigint_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_ord, selector text) +RETURNS eql_v3.bigint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param selector integer +--! @return eql_v3.bigint_ord +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_ord, selector integer) +RETURNS eql_v3.bigint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a jsonb +--! @param selector eql_v3.bigint_ord +--! @return eql_v3.bigint_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.bigint_ord) +RETURNS eql_v3.bigint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a jsonb +--! @param selector eql_v3.bigint_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.bigint_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.bigint_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.bigint_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.bigint_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.bigint_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.bigint_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.bigint_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.bigint_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.bigint_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b eql_v3.bigint_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_ord, b eql_v3.bigint_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a eql_v3.bigint_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_ord. +--! @param a jsonb +--! @param b eql_v3.bigint_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.bigint_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @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): +--! - eql_v3.json — storage/root: an EQL envelope object ({i, v, ...}). +--! - eql_v3.jsonb_entry — a single sv element (returned by `->`). +--! - eql_v3.jsonb_query — 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 `oc`). +CREATE FUNCTION eql_v3_internal.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 ? 'oc')) + OR + (jsonb_typeof(val -> 'oc') = 'string' AND NOT (val ? 'hm')) + ), + false + ) +$$; + +--! @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 +--! `oc`). +CREATE FUNCTION eql_v3_internal.is_valid_ste_vec_query_payload(val jsonb) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT 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 ? 'oc')) + OR + (jsonb_typeof(elem -> 'oc') = 'string' AND NOT (elem ? 'hm')) + ) + ), false) + ), + false + ) +$$; + +--! @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 FUNCTION eql_v3_internal.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 eql_v3_internal.is_valid_ste_vec_entry_payload(elem) + ), + false + ) +$$; + +--! @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 `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":[...]}'::eql_v3.json`. +CREATE DOMAIN eql_v3.json AS jsonb + CHECK ( + eql_v3_internal.is_valid_ste_vec_document_payload(VALUE) + ); + +--! @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 `oc` (CLLW ORE, 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.ore_cllw`. Extra fields (`a`, root +--! `i`/`v` merged in by `->`) are allowed. +--! +--! @see src/v3/jsonb/operators.sql +CREATE DOMAIN eql_v3.jsonb_entry AS jsonb + CHECK ( + eql_v3_internal.is_valid_ste_vec_entry_payload(VALUE) + ); + +--! @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 `oc`). 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":"<sel>","hm":"<hm>"}]}'::eql_v3.jsonb_query`. +--! @see eql_v3.to_ste_vec_query +CREATE DOMAIN eql_v3.jsonb_query AS jsonb + CHECK ( + eql_v3_internal.is_valid_ste_vec_query_payload(VALUE) + ); + +--! @brief Convert an eql_v3.json to a jsonb_query needle. +--! +--! Normalises each sv element down to the matching-relevant fields: `s` plus +--! exactly one of `hm` / `oc`. Other fields (`c`, `a`, `i`/`v`, anything else) +--! 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 eql_v3.json Source encrypted payload +--! @return eql_v3.jsonb_query Query-shaped needle, sv elements normalised. +--! @see eql_v3.jsonb_query +CREATE FUNCTION eql_v3.to_ste_vec_query(e eql_v3.json) + RETURNS eql_v3.jsonb_query + 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', + 'oc', elem -> 'oc' + ) + ) + ) + FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem), + '[]'::jsonb + ) + )::eql_v3.jsonb_query +$$; + +CREATE CAST (eql_v3.json AS eql_v3.jsonb_query) + WITH FUNCTION eql_v3.to_ste_vec_query + AS ASSIGNMENT; + +--! @file v3/sem/ore_cllw/operators.sql +--! @brief Comparison operators on the eql_v3_internal.ore_cllw composite type. +--! +--! Each backing function reduces to a single SELECT over +--! eql_v3_internal.compare_ore_cllw_term(a, b) and is inlinable so the planner can fold +--! it through to functional-index matching. The inner comparator is plpgsql +--! (per-byte loop) and is not inlined — fine for index *match*. +--! +--! @note Deliberately no HASHES / MERGES — the CLLW protocol gives ordering, +--! not a hash; there is no merge-joinable opclass on the other side. +--! @see eql_v3_internal.compare_ore_cllw_term + +--! @brief Equality backing function for eql_v3_internal.ore_cllw. +--! @internal +--! +--! @param a eql_v3_internal.ore_cllw Left operand +--! @param b eql_v3_internal.ore_cllw Right operand +--! @return boolean True if the CLLW ORE terms are equal +--! +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.ore_cllw_eq(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_cllw_term(a, b) = 0 +$$; + +--! @brief Not-equal backing function for eql_v3_internal.ore_cllw. +--! @internal +--! +--! @param a eql_v3_internal.ore_cllw Left operand +--! @param b eql_v3_internal.ore_cllw Right operand +--! @return boolean True if the CLLW ORE terms are not equal +--! +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.ore_cllw_neq(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_cllw_term(a, b) <> 0 +$$; + +--! @brief Less-than backing function for eql_v3_internal.ore_cllw. +--! @internal +--! +--! @param a eql_v3_internal.ore_cllw Left operand +--! @param b eql_v3_internal.ore_cllw Right operand +--! @return boolean True if the left operand is less than the right operand +--! +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.ore_cllw_lt(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_cllw_term(a, b) = -1 +$$; + +--! @brief Less-than-or-equal backing function for eql_v3_internal.ore_cllw. +--! @internal +--! +--! @param a eql_v3_internal.ore_cllw Left operand +--! @param b eql_v3_internal.ore_cllw Right operand +--! @return boolean True if the left operand is less than or equal to the right operand +--! +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.ore_cllw_lte(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_cllw_term(a, b) <> 1 +$$; + +--! @brief Greater-than backing function for eql_v3_internal.ore_cllw. +--! @internal +--! +--! @param a eql_v3_internal.ore_cllw Left operand +--! @param b eql_v3_internal.ore_cllw Right operand +--! @return boolean True if the left operand is greater than the right operand +--! +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.ore_cllw_gt(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_cllw_term(a, b) = 1 +$$; + +--! @brief Greater-than-or-equal backing function for eql_v3_internal.ore_cllw. +--! @internal +--! +--! @param a eql_v3_internal.ore_cllw Left operand +--! @param b eql_v3_internal.ore_cllw Right operand +--! @return boolean True if the left operand is greater than or equal to the right operand +--! +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.ore_cllw_gte(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_cllw_term(a, b) <> -1 +$$; + + +CREATE OPERATOR public.= ( + FUNCTION = eql_v3_internal.ore_cllw_eq, + LEFTARG = eql_v3_internal.ore_cllw, + RIGHTARG = eql_v3_internal.ore_cllw, + COMMUTATOR = OPERATOR(public.=), + NEGATOR = OPERATOR(public.<>), + RESTRICT = eqsel, + JOIN = eqjoinsel +); + +CREATE OPERATOR public.<> ( + FUNCTION = eql_v3_internal.ore_cllw_neq, + LEFTARG = eql_v3_internal.ore_cllw, + RIGHTARG = eql_v3_internal.ore_cllw, + COMMUTATOR = OPERATOR(public.<>), + NEGATOR = OPERATOR(public.=), + RESTRICT = neqsel, + JOIN = neqjoinsel +); + +CREATE OPERATOR public.< ( + FUNCTION = eql_v3_internal.ore_cllw_lt, + LEFTARG = eql_v3_internal.ore_cllw, + RIGHTARG = eql_v3_internal.ore_cllw, + COMMUTATOR = OPERATOR(public.>), + NEGATOR = OPERATOR(public.>=), + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel +); + +CREATE OPERATOR public.<= ( + FUNCTION = eql_v3_internal.ore_cllw_lte, + LEFTARG = eql_v3_internal.ore_cllw, + RIGHTARG = eql_v3_internal.ore_cllw, + COMMUTATOR = OPERATOR(public.>=), + NEGATOR = OPERATOR(public.>), + RESTRICT = scalarlesel, + JOIN = scalarlejoinsel +); + +CREATE OPERATOR public.> ( + FUNCTION = eql_v3_internal.ore_cllw_gt, + LEFTARG = eql_v3_internal.ore_cllw, + RIGHTARG = eql_v3_internal.ore_cllw, + COMMUTATOR = OPERATOR(public.<), + NEGATOR = OPERATOR(public.<=), + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel +); + +CREATE OPERATOR public.>= ( + FUNCTION = eql_v3_internal.ore_cllw_gte, + LEFTARG = eql_v3_internal.ore_cllw, + RIGHTARG = eql_v3_internal.ore_cllw, + COMMUTATOR = OPERATOR(public.<=), + NEGATOR = OPERATOR(public.<), + RESTRICT = scalargesel, + JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ore_operators.sql +--! @brief Operators for eql_v3.timestamp_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = eql_v3.timestamp_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.timestamp_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ope_operators.sql +--! @brief Operators for eql_v3.timestamp_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = eql_v3.timestamp_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.timestamp_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_operators.sql +--! @brief Operators for eql_v3.timestamp_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = eql_v3.timestamp_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.timestamp_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_functions.sql +--! @brief Functions for eql_v3.timestamp. + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.timestamp, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a jsonb +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.timestamp, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a jsonb +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.timestamp, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a jsonb +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.timestamp, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a jsonb +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.timestamp, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a jsonb +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.timestamp, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a jsonb +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a jsonb +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a jsonb +--! @param b eql_v3.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param selector text +--! @return eql_v3.timestamp +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp, selector text) +RETURNS eql_v3.timestamp IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param selector integer +--! @return eql_v3.timestamp +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp, selector integer) +RETURNS eql_v3.timestamp IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a jsonb +--! @param selector eql_v3.timestamp +--! @return eql_v3.timestamp +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.timestamp) +RETURNS eql_v3.timestamp IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a jsonb +--! @param selector eql_v3.timestamp +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.timestamp) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.timestamp, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.timestamp, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.timestamp, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.timestamp, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.timestamp, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.timestamp, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.timestamp, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.timestamp, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b eql_v3.timestamp +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp, b eql_v3.timestamp) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a eql_v3.timestamp +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp. +--! @param a jsonb +--! @param b eql_v3.timestamp +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.timestamp) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_eq_functions.sql +--! @brief Functions for eql_v3.timestamp_eq. + +--! @brief Index extractor for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.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.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_eq, b 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.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.timestamp_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.timestamp_eq) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_eq. +--! @param a jsonb +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.timestamp_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.timestamp_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_eq, b 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.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.timestamp_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.timestamp_eq) $$; + +--! @brief Operator wrapper for eql_v3.timestamp_eq. +--! @param a jsonb +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.timestamp_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.timestamp_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a jsonb +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a jsonb +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a jsonb +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a jsonb +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a jsonb +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a jsonb +--! @param b eql_v3.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param selector text +--! @return eql_v3.timestamp_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_eq, selector text) +RETURNS eql_v3.timestamp_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param selector integer +--! @return eql_v3.timestamp_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.timestamp_eq, selector integer) +RETURNS eql_v3.timestamp_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a jsonb +--! @param selector eql_v3.timestamp_eq +--! @return eql_v3.timestamp_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.timestamp_eq) +RETURNS eql_v3.timestamp_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.timestamp_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a jsonb +--! @param selector eql_v3.timestamp_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.timestamp_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.timestamp_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.timestamp_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.timestamp_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.timestamp_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.timestamp_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.timestamp_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.timestamp_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.timestamp_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.timestamp_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b eql_v3.timestamp_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_eq, b eql_v3.timestamp_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a eql_v3.timestamp_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.timestamp_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.timestamp_eq. +--! @param a jsonb +--! @param b eql_v3.timestamp_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.timestamp_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.timestamp_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_search_operators.sql +--! @brief Operators for eql_v3.text_search. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.text_search, RIGHTARG = jsonb, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text_search, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text_search, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text_search, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text_search, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.text_search, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.text_search, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.text_search, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.text_search, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.text_search, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.text_search, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.text_search, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_search, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_search, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_search, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.text_search, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text_search, RIGHTARG = eql_v3.text_search +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text_search, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_search +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ore_operators.sql +--! @brief Operators for eql_v3.text_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = eql_v3.text_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ope_operators.sql +--! @brief Operators for eql_v3.text_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = eql_v3.text_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_operators.sql +--! @brief Operators for eql_v3.text_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.text_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.text_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.text_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.text_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.text_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.text_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text_ord, RIGHTARG = eql_v3.text_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_functions.sql +--! @brief Functions for eql_v3.text. + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.text, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a jsonb +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.text, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a jsonb +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.text, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a jsonb +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.text, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a jsonb +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.text, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a jsonb +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.text, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a jsonb +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a jsonb +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a jsonb +--! @param b eql_v3.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param selector text +--! @return eql_v3.text +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text, selector text) +RETURNS eql_v3.text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param selector integer +--! @return eql_v3.text +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text, selector integer) +RETURNS eql_v3.text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a jsonb +--! @param selector eql_v3.text +--! @return eql_v3.text +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text) +RETURNS eql_v3.text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a jsonb +--! @param selector eql_v3.text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b eql_v3.text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text, b eql_v3.text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a eql_v3.text +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text. +--! @param a jsonb +--! @param b eql_v3.text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_match_functions.sql +--! @brief Functions for eql_v3.text_match. + +--! @brief Index extractor for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @return eql_v3_internal.bloom_filter +CREATE FUNCTION eql_v3.match_term(a 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 eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.text_match, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a jsonb +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.text_match, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a jsonb +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.text_match, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a jsonb +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.text_match, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a jsonb +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.text_match, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a jsonb +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.text_match, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a jsonb +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Operator wrapper for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3.contains(a eql_v3.text_match, b 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.text_match. +--! @param a eql_v3.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(a 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::eql_v3.text_match) $$; + +--! @brief Operator wrapper for eql_v3.text_match. +--! @param a jsonb +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3.contains(a jsonb, b eql_v3.text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::eql_v3.text_match) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a eql_v3.text_match, b 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.text_match. +--! @param a eql_v3.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a 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::eql_v3.text_match) $$; + +--! @brief Operator wrapper for eql_v3.text_match. +--! @param a jsonb +--! @param b eql_v3.text_match +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a jsonb, b eql_v3.text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::eql_v3.text_match) <@ eql_v3.match_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param selector text +--! @return eql_v3.text_match +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_match, selector text) +RETURNS eql_v3.text_match IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param selector integer +--! @return eql_v3.text_match +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_match, selector integer) +RETURNS eql_v3.text_match IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a jsonb +--! @param selector eql_v3.text_match +--! @return eql_v3.text_match +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text_match) +RETURNS eql_v3.text_match IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_match, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_match, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a jsonb +--! @param selector eql_v3.text_match +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text_match) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text_match, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text_match, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text_match, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text_match, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text_match, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text_match, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text_match, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_match, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_match, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_match, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text_match, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b eql_v3.text_match +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_match, b eql_v3.text_match) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a eql_v3.text_match +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_match, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_match. +--! @param a jsonb +--! @param b eql_v3.text_match +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text_match) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_match'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_eq_functions.sql +--! @brief Functions for eql_v3.text_eq. + +--! @brief Index extractor for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a 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 eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.text_eq, b 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 Operator wrapper for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.text_eq) $$; + +--! @brief Operator wrapper for eql_v3.text_eq. +--! @param a jsonb +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.text_eq, b 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 Operator wrapper for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.text_eq) $$; + +--! @brief Operator wrapper for eql_v3.text_eq. +--! @param a jsonb +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.text_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.text_eq, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a jsonb +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.text_eq, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a jsonb +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.text_eq, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a jsonb +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.text_eq, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a jsonb +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_eq, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a jsonb +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_eq, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a jsonb +--! @param b eql_v3.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param selector text +--! @return eql_v3.text_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_eq, selector text) +RETURNS eql_v3.text_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param selector integer +--! @return eql_v3.text_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.text_eq, selector integer) +RETURNS eql_v3.text_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a jsonb +--! @param selector eql_v3.text_eq +--! @return eql_v3.text_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.text_eq) +RETURNS eql_v3.text_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.text_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a jsonb +--! @param selector eql_v3.text_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.text_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.text_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.text_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.text_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.text_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.text_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.text_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.text_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.text_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.text_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b eql_v3.text_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_eq, b eql_v3.text_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a eql_v3.text_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.text_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.text_eq. +--! @param a jsonb +--! @param b eql_v3.text_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.text_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.text_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ore_operators.sql +--! @brief Operators for eql_v3.smallint_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = eql_v3.smallint_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.smallint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ope_operators.sql +--! @brief Operators for eql_v3.smallint_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = eql_v3.smallint_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.smallint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_operators.sql +--! @brief Operators for eql_v3.smallint_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = eql_v3.smallint_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.smallint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_functions.sql +--! @brief Functions for eql_v3.smallint. + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.smallint, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a jsonb +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.smallint, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a jsonb +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.smallint, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a jsonb +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.smallint, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a jsonb +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.smallint, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a jsonb +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.smallint, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a jsonb +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a jsonb +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a jsonb +--! @param b eql_v3.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param selector text +--! @return eql_v3.smallint +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint, selector text) +RETURNS eql_v3.smallint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param selector integer +--! @return eql_v3.smallint +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint, selector integer) +RETURNS eql_v3.smallint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a jsonb +--! @param selector eql_v3.smallint +--! @return eql_v3.smallint +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.smallint) +RETURNS eql_v3.smallint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a jsonb +--! @param selector eql_v3.smallint +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.smallint) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.smallint, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.smallint, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.smallint, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.smallint, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.smallint, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.smallint, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.smallint, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.smallint, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b eql_v3.smallint +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint, b eql_v3.smallint) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a eql_v3.smallint +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint. +--! @param a jsonb +--! @param b eql_v3.smallint +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.smallint) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_eq_functions.sql +--! @brief Functions for eql_v3.smallint_eq. + +--! @brief Index extractor for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a 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 Operator wrapper for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.smallint_eq, b 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.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.smallint_eq) $$; + +--! @brief Operator wrapper for eql_v3.smallint_eq. +--! @param a jsonb +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.smallint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.smallint_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.smallint_eq, b 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.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.smallint_eq) $$; + +--! @brief Operator wrapper for eql_v3.smallint_eq. +--! @param a jsonb +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.smallint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.smallint_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.smallint_eq, b eql_v3.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a jsonb +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.smallint_eq, b eql_v3.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a jsonb +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.smallint_eq, b eql_v3.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a jsonb +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.smallint_eq, b eql_v3.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a jsonb +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_eq, b eql_v3.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a jsonb +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_eq, b eql_v3.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a jsonb +--! @param b eql_v3.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param selector text +--! @return eql_v3.smallint_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_eq, selector text) +RETURNS eql_v3.smallint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param selector integer +--! @return eql_v3.smallint_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.smallint_eq, selector integer) +RETURNS eql_v3.smallint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a jsonb +--! @param selector eql_v3.smallint_eq +--! @return eql_v3.smallint_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.smallint_eq) +RETURNS eql_v3.smallint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.smallint_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a jsonb +--! @param selector eql_v3.smallint_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.smallint_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.smallint_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.smallint_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.smallint_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.smallint_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.smallint_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.smallint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.smallint_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.smallint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.smallint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b eql_v3.smallint_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_eq, b eql_v3.smallint_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a eql_v3.smallint_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.smallint_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.smallint_eq. +--! @param a jsonb +--! @param b eql_v3.smallint_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.smallint_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.smallint_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ore_operators.sql +--! @brief Operators for eql_v3.real_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = eql_v3.real_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.real_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ope_operators.sql +--! @brief Operators for eql_v3.real_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = eql_v3.real_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.real_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_operators.sql +--! @brief Operators for eql_v3.real_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.real_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.real_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.real_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.real_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.real_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.real_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.real_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.real_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.real_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.real_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.real_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.real_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.real_ord, RIGHTARG = eql_v3.real_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.real_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.real_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_functions.sql +--! @brief Functions for eql_v3.real. + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.real, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a jsonb +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.real, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a jsonb +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.real, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a jsonb +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.real, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a jsonb +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.real, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a jsonb +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.real, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a jsonb +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a jsonb +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a jsonb +--! @param b eql_v3.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param selector text +--! @return eql_v3.real +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real, selector text) +RETURNS eql_v3.real IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param selector integer +--! @return eql_v3.real +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real, selector integer) +RETURNS eql_v3.real IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a jsonb +--! @param selector eql_v3.real +--! @return eql_v3.real +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.real) +RETURNS eql_v3.real IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a jsonb +--! @param selector eql_v3.real +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.real) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.real, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.real, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.real, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.real, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.real, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.real, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.real, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.real, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b eql_v3.real +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real, b eql_v3.real) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a eql_v3.real +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real. +--! @param a jsonb +--! @param b eql_v3.real +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.real) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_eq_functions.sql +--! @brief Functions for eql_v3.real_eq. + +--! @brief Index extractor for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a 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 Operator wrapper for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.real_eq, b 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.real_eq. +--! @param a eql_v3.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.real_eq) $$; + +--! @brief Operator wrapper for eql_v3.real_eq. +--! @param a jsonb +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.real_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.real_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.real_eq, b 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.real_eq. +--! @param a eql_v3.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.real_eq) $$; + +--! @brief Operator wrapper for eql_v3.real_eq. +--! @param a jsonb +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.real_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.real_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.real_eq, b eql_v3.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a jsonb +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.real_eq, b eql_v3.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a jsonb +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.real_eq, b eql_v3.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a jsonb +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.real_eq, b eql_v3.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a jsonb +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_eq, b eql_v3.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a jsonb +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_eq, b eql_v3.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a jsonb +--! @param b eql_v3.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param selector text +--! @return eql_v3.real_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_eq, selector text) +RETURNS eql_v3.real_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param selector integer +--! @return eql_v3.real_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.real_eq, selector integer) +RETURNS eql_v3.real_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a jsonb +--! @param selector eql_v3.real_eq +--! @return eql_v3.real_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.real_eq) +RETURNS eql_v3.real_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.real_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a jsonb +--! @param selector eql_v3.real_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.real_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.real_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.real_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.real_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.real_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.real_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.real_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.real_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.real_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.real_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b eql_v3.real_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_eq, b eql_v3.real_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a eql_v3.real_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.real_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.real_eq. +--! @param a jsonb +--! @param b eql_v3.real_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.real_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.real_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ore_operators.sql +--! @brief Operators for eql_v3.numeric_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = eql_v3.numeric_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.numeric_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ope_operators.sql +--! @brief Operators for eql_v3.numeric_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = eql_v3.numeric_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.numeric_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_operators.sql +--! @brief Operators for eql_v3.numeric_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = eql_v3.numeric_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.numeric_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_functions.sql +--! @brief Functions for eql_v3.numeric. + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.numeric, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.numeric, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.numeric, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.numeric, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.numeric, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.numeric, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param b eql_v3.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param selector text +--! @return eql_v3.numeric +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric, selector text) +RETURNS eql_v3.numeric IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param selector integer +--! @return eql_v3.numeric +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric, selector integer) +RETURNS eql_v3.numeric IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param selector eql_v3.numeric +--! @return eql_v3.numeric +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.numeric) +RETURNS eql_v3.numeric IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param selector eql_v3.numeric +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.numeric) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.numeric, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.numeric, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.numeric, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.numeric, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.numeric, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.numeric, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.numeric, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.numeric, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b eql_v3.numeric +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric, b eql_v3.numeric) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a eql_v3.numeric +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric. +--! @param a jsonb +--! @param b eql_v3.numeric +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.numeric) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_eq_functions.sql +--! @brief Functions for eql_v3.numeric_eq. + +--! @brief Index extractor for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a eql_v3.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.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_eq, b 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.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.numeric_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.numeric_eq) $$; + +--! @brief Operator wrapper for eql_v3.numeric_eq. +--! @param a jsonb +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.numeric_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.numeric_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_eq, b 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.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.numeric_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.numeric_eq) $$; + +--! @brief Operator wrapper for eql_v3.numeric_eq. +--! @param a jsonb +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.numeric_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.numeric_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.numeric_eq, b eql_v3.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a jsonb +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.numeric_eq, b eql_v3.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a jsonb +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.numeric_eq, b eql_v3.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a jsonb +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.numeric_eq, b eql_v3.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a jsonb +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_eq, b eql_v3.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a jsonb +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_eq, b eql_v3.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a jsonb +--! @param b eql_v3.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param selector text +--! @return eql_v3.numeric_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_eq, selector text) +RETURNS eql_v3.numeric_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param selector integer +--! @return eql_v3.numeric_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.numeric_eq, selector integer) +RETURNS eql_v3.numeric_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a jsonb +--! @param selector eql_v3.numeric_eq +--! @return eql_v3.numeric_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.numeric_eq) +RETURNS eql_v3.numeric_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.numeric_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a jsonb +--! @param selector eql_v3.numeric_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.numeric_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.numeric_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.numeric_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.numeric_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.numeric_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.numeric_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.numeric_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.numeric_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.numeric_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.numeric_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b eql_v3.numeric_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_eq, b eql_v3.numeric_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a eql_v3.numeric_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.numeric_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.numeric_eq. +--! @param a jsonb +--! @param b eql_v3.numeric_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.numeric_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.numeric_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ore_operators.sql +--! @brief Operators for eql_v3.integer_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = eql_v3.integer_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.integer_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ope_operators.sql +--! @brief Operators for eql_v3.integer_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = eql_v3.integer_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.integer_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_operators.sql +--! @brief Operators for eql_v3.integer_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.integer_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.integer_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.integer_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.integer_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.integer_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.integer_ord, RIGHTARG = eql_v3.integer_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.integer_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_functions.sql +--! @brief Functions for eql_v3.integer. + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.integer, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a jsonb +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.integer, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a jsonb +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.integer, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a jsonb +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.integer, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a jsonb +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.integer, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a jsonb +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.integer, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a jsonb +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a jsonb +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a jsonb +--! @param b eql_v3.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param selector text +--! @return eql_v3.integer +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer, selector text) +RETURNS eql_v3.integer IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param selector integer +--! @return eql_v3.integer +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer, selector integer) +RETURNS eql_v3.integer IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a jsonb +--! @param selector eql_v3.integer +--! @return eql_v3.integer +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.integer) +RETURNS eql_v3.integer IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a jsonb +--! @param selector eql_v3.integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.integer, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.integer, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.integer, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.integer, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.integer, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.integer, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.integer, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.integer, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b eql_v3.integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer, b eql_v3.integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a eql_v3.integer +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer. +--! @param a jsonb +--! @param b eql_v3.integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_eq_functions.sql +--! @brief Functions for eql_v3.integer_eq. + +--! @brief Index extractor for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a 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 eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.integer_eq, b 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 eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.integer_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::eql_v3.integer_eq) $$; + +--! @brief Operator wrapper for eql_v3.integer_eq. +--! @param a jsonb +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.integer_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.integer_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.integer_eq, b 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 eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.integer_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::eql_v3.integer_eq) $$; + +--! @brief Operator wrapper for eql_v3.integer_eq. +--! @param a jsonb +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.integer_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.integer_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.integer_eq, b eql_v3.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a jsonb +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.integer_eq, b eql_v3.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a jsonb +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.integer_eq, b eql_v3.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a jsonb +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.integer_eq, b eql_v3.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a jsonb +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_eq, b eql_v3.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a jsonb +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_eq, b eql_v3.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a jsonb +--! @param b eql_v3.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param selector text +--! @return eql_v3.integer_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_eq, selector text) +RETURNS eql_v3.integer_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param selector integer +--! @return eql_v3.integer_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.integer_eq, selector integer) +RETURNS eql_v3.integer_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a jsonb +--! @param selector eql_v3.integer_eq +--! @return eql_v3.integer_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.integer_eq) +RETURNS eql_v3.integer_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.integer_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a jsonb +--! @param selector eql_v3.integer_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.integer_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.integer_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.integer_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.integer_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.integer_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.integer_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.integer_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.integer_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.integer_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.integer_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b eql_v3.integer_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_eq, b eql_v3.integer_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a eql_v3.integer_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.integer_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.integer_eq. +--! @param a jsonb +--! @param b eql_v3.integer_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.integer_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.integer_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ore_operators.sql +--! @brief Operators for eql_v3.double_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = eql_v3.double_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.double_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ope_operators.sql +--! @brief Operators for eql_v3.double_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = eql_v3.double_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.double_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_operators.sql +--! @brief Operators for eql_v3.double_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.double_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.double_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.double_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.double_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.double_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.double_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.double_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.double_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.double_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.double_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.double_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.double_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.double_ord, RIGHTARG = eql_v3.double_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.double_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.double_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_functions.sql +--! @brief Functions for eql_v3.double. + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.double, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a jsonb +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.double, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a jsonb +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.double, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a jsonb +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.double, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a jsonb +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.double, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a jsonb +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.double, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a jsonb +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a jsonb +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a jsonb +--! @param b eql_v3.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param selector text +--! @return eql_v3.double +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double, selector text) +RETURNS eql_v3.double IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param selector integer +--! @return eql_v3.double +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double, selector integer) +RETURNS eql_v3.double IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a jsonb +--! @param selector eql_v3.double +--! @return eql_v3.double +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.double) +RETURNS eql_v3.double IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a jsonb +--! @param selector eql_v3.double +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.double) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.double, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.double, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.double, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.double, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.double, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.double, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.double, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.double, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b eql_v3.double +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double, b eql_v3.double) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a eql_v3.double +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double. +--! @param a jsonb +--! @param b eql_v3.double +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.double) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_eq_functions.sql +--! @brief Functions for eql_v3.double_eq. + +--! @brief Index extractor for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a 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 eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.double_eq, b 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 eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.double_eq) $$; + +--! @brief Operator wrapper for eql_v3.double_eq. +--! @param a jsonb +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.double_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.double_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.double_eq, b 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 eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.double_eq) $$; + +--! @brief Operator wrapper for eql_v3.double_eq. +--! @param a jsonb +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.double_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.double_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.double_eq, b eql_v3.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a jsonb +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.double_eq, b eql_v3.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a jsonb +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.double_eq, b eql_v3.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a jsonb +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.double_eq, b eql_v3.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a jsonb +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_eq, b eql_v3.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a jsonb +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_eq, b eql_v3.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a jsonb +--! @param b eql_v3.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param selector text +--! @return eql_v3.double_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_eq, selector text) +RETURNS eql_v3.double_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param selector integer +--! @return eql_v3.double_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.double_eq, selector integer) +RETURNS eql_v3.double_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a jsonb +--! @param selector eql_v3.double_eq +--! @return eql_v3.double_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.double_eq) +RETURNS eql_v3.double_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.double_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a jsonb +--! @param selector eql_v3.double_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.double_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.double_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.double_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.double_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.double_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.double_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.double_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.double_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.double_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.double_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b eql_v3.double_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_eq, b eql_v3.double_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a eql_v3.double_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.double_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.double_eq. +--! @param a jsonb +--! @param b eql_v3.double_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.double_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.double_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ore_operators.sql +--! @brief Operators for eql_v3.date_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = eql_v3.date_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.date_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ope_operators.sql +--! @brief Operators for eql_v3.date_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = eql_v3.date_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.date_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_operators.sql +--! @brief Operators for eql_v3.date_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.date_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.date_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.date_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.date_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.date_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.date_ord, RIGHTARG = eql_v3.date_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.date_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_functions.sql +--! @brief Functions for eql_v3.date. + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.date, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.date, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.date, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.date, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.date, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.date, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param b eql_v3.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param selector text +--! @return eql_v3.date +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date, selector text) +RETURNS eql_v3.date IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param selector integer +--! @return eql_v3.date +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date, selector integer) +RETURNS eql_v3.date IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param selector eql_v3.date +--! @return eql_v3.date +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.date) +RETURNS eql_v3.date IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param selector eql_v3.date +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.date) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.date, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.date, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.date, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.date, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.date, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.date, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.date, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.date, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b eql_v3.date +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date, b eql_v3.date) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a eql_v3.date +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date. +--! @param a jsonb +--! @param b eql_v3.date +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.date) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_eq_functions.sql +--! @brief Functions for eql_v3.date_eq. + +--! @brief Index extractor for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a 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 eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.date_eq, b 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.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.date_eq) $$; + +--! @brief Operator wrapper for eql_v3.date_eq. +--! @param a jsonb +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.date_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.date_eq, b 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.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.date_eq) $$; + +--! @brief Operator wrapper for eql_v3.date_eq. +--! @param a jsonb +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.date_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.date_eq, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a jsonb +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.date_eq, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a jsonb +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.date_eq, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a jsonb +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.date_eq, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a jsonb +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_eq, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a jsonb +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_eq, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a jsonb +--! @param b eql_v3.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param selector text +--! @return eql_v3.date_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_eq, selector text) +RETURNS eql_v3.date_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param selector integer +--! @return eql_v3.date_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.date_eq, selector integer) +RETURNS eql_v3.date_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a jsonb +--! @param selector eql_v3.date_eq +--! @return eql_v3.date_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.date_eq) +RETURNS eql_v3.date_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.date_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a jsonb +--! @param selector eql_v3.date_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.date_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.date_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.date_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.date_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.date_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.date_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.date_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.date_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.date_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.date_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b eql_v3.date_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_eq, b eql_v3.date_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a eql_v3.date_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.date_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.date_eq. +--! @param a jsonb +--! @param b eql_v3.date_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.date_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.date_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/boolean/boolean_functions.sql +--! @brief Functions for eql_v3.boolean. + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.boolean, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a jsonb +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.boolean, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a jsonb +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.boolean, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a jsonb +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.boolean, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a jsonb +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.boolean, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a jsonb +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.boolean, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a jsonb +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.boolean, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a jsonb +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.boolean, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a jsonb +--! @param b eql_v3.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param selector text +--! @return eql_v3.boolean +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.boolean, selector text) +RETURNS eql_v3.boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param selector integer +--! @return eql_v3.boolean +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.boolean, selector integer) +RETURNS eql_v3.boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a jsonb +--! @param selector eql_v3.boolean +--! @return eql_v3.boolean +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.boolean) +RETURNS eql_v3.boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.boolean, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.boolean, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a jsonb +--! @param selector eql_v3.boolean +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.boolean) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.boolean, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.boolean, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.boolean, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.boolean, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.boolean, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.boolean, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.boolean, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.boolean, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.boolean, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.boolean, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.boolean, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b eql_v3.boolean +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.boolean, b eql_v3.boolean) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a eql_v3.boolean +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.boolean, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.boolean. +--! @param a jsonb +--! @param b eql_v3.boolean +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.boolean) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.boolean'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ore_operators.sql +--! @brief Operators for eql_v3.bigint_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = eql_v3.bigint_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.bigint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ope_operators.sql +--! @brief Operators for eql_v3.bigint_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = eql_v3.bigint_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.bigint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_operators.sql +--! @brief Operators for eql_v3.bigint_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = eql_v3.bigint_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.bigint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_functions.sql +--! @brief Functions for eql_v3.bigint. + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.bigint, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a eql_v3.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a jsonb +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.bigint, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a eql_v3.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a jsonb +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.bigint, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a jsonb +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.bigint, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a jsonb +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.bigint, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a jsonb +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.bigint, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a jsonb +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a jsonb +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a jsonb +--! @param b eql_v3.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param selector text +--! @return eql_v3.bigint +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint, selector text) +RETURNS eql_v3.bigint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param selector integer +--! @return eql_v3.bigint +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint, selector integer) +RETURNS eql_v3.bigint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a jsonb +--! @param selector eql_v3.bigint +--! @return eql_v3.bigint +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.bigint) +RETURNS eql_v3.bigint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a jsonb +--! @param selector eql_v3.bigint +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.bigint) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.bigint, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.bigint, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.bigint, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.bigint, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.bigint, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.bigint, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.bigint, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.bigint, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b eql_v3.bigint +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint, b eql_v3.bigint) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a eql_v3.bigint +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint. +--! @param a jsonb +--! @param b eql_v3.bigint +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.bigint) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_eq_functions.sql +--! @brief Functions for eql_v3.bigint_eq. + +--! @brief Index extractor for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a 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 eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a eql_v3.bigint_eq, b 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 eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a 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::eql_v3.bigint_eq) $$; + +--! @brief Operator wrapper for eql_v3.bigint_eq. +--! @param a jsonb +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b eql_v3.bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.bigint_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a eql_v3.bigint_eq, b 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 eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a 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::eql_v3.bigint_eq) $$; + +--! @brief Operator wrapper for eql_v3.bigint_eq. +--! @param a jsonb +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b eql_v3.bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::eql_v3.bigint_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.bigint_eq, b eql_v3.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a eql_v3.bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a jsonb +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b eql_v3.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.bigint_eq, b eql_v3.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a eql_v3.bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a jsonb +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b eql_v3.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.bigint_eq, b eql_v3.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a eql_v3.bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a jsonb +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b eql_v3.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.bigint_eq, b eql_v3.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a eql_v3.bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a jsonb +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b eql_v3.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_eq, b eql_v3.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a eql_v3.bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a jsonb +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b eql_v3.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_eq, b eql_v3.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a eql_v3.bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a jsonb +--! @param b eql_v3.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b eql_v3.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param selector text +--! @return eql_v3.bigint_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_eq, selector text) +RETURNS eql_v3.bigint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param selector integer +--! @return eql_v3.bigint_eq +CREATE FUNCTION eql_v3_internal."->"(a eql_v3.bigint_eq, selector integer) +RETURNS eql_v3.bigint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a jsonb +--! @param selector eql_v3.bigint_eq +--! @return eql_v3.bigint_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector eql_v3.bigint_eq) +RETURNS eql_v3.bigint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a eql_v3.bigint_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a jsonb +--! @param selector eql_v3.bigint_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector eql_v3.bigint_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a eql_v3.bigint_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a eql_v3.bigint_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a eql_v3.bigint_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a eql_v3.bigint_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a eql_v3.bigint_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a eql_v3.bigint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a eql_v3.bigint_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a eql_v3.bigint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a eql_v3.bigint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b eql_v3.bigint_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_eq, b eql_v3.bigint_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a eql_v3.bigint_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a eql_v3.bigint_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for eql_v3.bigint_eq. +--! @param a jsonb +--! @param b eql_v3.bigint_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b eql_v3.bigint_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'eql_v3.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @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. + +------------------------------------------------------------------------------ +-- Envelope helpers (eql_v3 owns these; jsonb-only) +------------------------------------------------------------------------------ + +--! @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'); +$$; + +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)'; + +--! @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; + +------------------------------------------------------------------------------ +-- Selector extractors +------------------------------------------------------------------------------ + +--! @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; + +--! @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 eql_v3.jsonb_entry +--! @return text The selector value. +CREATE FUNCTION eql_v3.selector(entry eql_v3.jsonb_entry) + RETURNS text + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT entry ->> 's' +$$; + +------------------------------------------------------------------------------ +-- Equality-term extractor (XOR-aware: coalesce(hm, oc)) +------------------------------------------------------------------------------ + +--! @brief XOR-aware equality term extractor for eql_v3.jsonb_entry. +--! +--! Returns the bytea of whichever deterministic term the sv entry carries — +--! `hm` (HMAC-256) or `oc` (CLLW ORE). 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 eql_v3.jsonb_entry +--! @return bytea Decoded `hm` or `oc` bytes (NULL if entry is NULL). +CREATE FUNCTION eql_v3.eq_term(entry eql_v3.jsonb_entry) + RETURNS bytea + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT decode(coalesce(entry ->> 'hm', entry ->> 'oc'), 'hex') +$$; + +------------------------------------------------------------------------------ +-- ORE CLLW per-entry overloads (live here so sem/ore_cllw stays a leaf) +------------------------------------------------------------------------------ + +--! @brief Extract CLLW ORE index term from a ste_vec entry. +--! +--! `oc` is only ever present on an sv element, never at a root encrypted value, +--! so the typed overload accepts eql_v3.jsonb_entry. Returns SQL NULL when +--! `oc` is absent (btree NULL-filters such rows from range queries). +--! +--! @param entry eql_v3.jsonb_entry +--! @return eql_v3_internal.ore_cllw Composite carrying the CLLW ciphertext, or NULL. +--! @see eql_v3.has_ore_cllw +CREATE FUNCTION eql_v3.ore_cllw(entry eql_v3.jsonb_entry) + RETURNS eql_v3_internal.ore_cllw + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT CASE WHEN entry ->> 'oc' IS NULL THEN NULL + ELSE ROW(decode(entry ->> 'oc', 'hex'))::eql_v3_internal.ore_cllw + END +$$; + +--! @brief Check if a ste_vec entry contains a CLLW ORE index term. +--! @param entry eql_v3.jsonb_entry +--! @return boolean True if `oc` is present and non-null. +CREATE FUNCTION eql_v3.has_ore_cllw(entry eql_v3.jsonb_entry) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT entry ->> 'oc' IS NOT NULL +$$; + +------------------------------------------------------------------------------ +-- sv-array helpers +------------------------------------------------------------------------------ + +--! @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; + + SELECT array_agg(elem) + INTO ary + FROM jsonb_array_elements(sv) AS elem; + + RETURN ary; + END; +$$ LANGUAGE plpgsql; + +--! @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; + +------------------------------------------------------------------------------ +-- Deterministic-fields array for GIN containment +------------------------------------------------------------------------------ + +--! @brief Extract deterministic search fields (s, hm, oc, 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', 'oc', 'op') + GROUP BY elem + ); +$$; + +COMMENT ON FUNCTION eql_v3.jsonb_array(jsonb) IS + 'eql-inline-critical: raw-jsonb deterministic-field array helper; must stay inlinable (unpinned search_path)'; + +------------------------------------------------------------------------------ +-- Containment +------------------------------------------------------------------------------ + +--! @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 +--! `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 +AS $$ + SELECT eql_v3.jsonb_array(a) @> eql_v3.jsonb_array(b); +$$; + +COMMENT ON FUNCTION eql_v3.jsonb_contains(jsonb, jsonb) IS + 'eql-inline-critical: raw-jsonb containment helper; must stay inlinable (unpinned search_path)'; + +--! @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 +--! `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 +AS $$ + SELECT eql_v3.jsonb_array(a) <@ eql_v3.jsonb_array(b); +$$; + +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 Check if an sv array contains a specific sv element. +--! +--! Match = selector equal AND eq_term equal (byte-equality over coalesce(hm, +--! oc)). 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 oc 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; and an oc value carries a leading domain-tag byte an hm never +--! has. Unlike v2's explicit `has_hmac(both)`/`has_ore_cllw(both)`/`ELSE false` +--! CASE, this collapse would wrongly match an hm needle against an oc leaf if +--! their hex bytes were ever identical — which the contract prevents. 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; + + 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::eql_v3.jsonb_entry) = eql_v3.eq_term(b::eql_v3.jsonb_entry) + ); + EXIT WHEN result; + END LOOP; + + RETURN result; + END; +$$ LANGUAGE plpgsql; + +--! @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 eql_v3.json Container. +--! @param b 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 eql_v3.json, b 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); + + IF array_length(sv_b, 1) IS NULL THEN + RETURN true; + END IF; + + IF array_length(sv_a, 1) IS NULL THEN + RETURN false; + END IF; + + result := true; + + 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; + + RETURN result; + END; +$$ LANGUAGE plpgsql; + +------------------------------------------------------------------------------ +-- Path queries (text selector only) +------------------------------------------------------------------------------ + +--! @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 +--! eql_v3.json document, because the root document domain requires an `sv` +--! array and single leaves belong to eql_v3.jsonb_entry. +--! +--! @param val jsonb encrypted EQL payload with `sv`. +--! @param selector text Selector hash (`s` value). +--! @return SETOF 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 eql_v3.jsonb_entry + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT (eql_v3.meta_data(val) || elem)::eql_v3.jsonb_entry + FROM jsonb_array_elements(val -> 'sv') elem + WHERE elem ->> 's' = selector +$$; + +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)'; + +--! @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 + ); +$$; + +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)'; + +--! @brief Get the first sv element matching `selector`, or NULL. +--! @param val jsonb encrypted EQL payload. +--! @param selector text Selector hash to match. +--! @return eql_v3.jsonb_entry First matching element or NULL. +CREATE FUNCTION eql_v3.jsonb_path_query_first(val jsonb, selector text) + RETURNS eql_v3.jsonb_entry + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT (eql_v3.meta_data(val) || elem)::eql_v3.jsonb_entry + FROM jsonb_array_elements(val -> 'sv') elem + WHERE elem ->> 's' = selector + LIMIT 1 +$$; + +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)'; + +------------------------------------------------------------------------------ +-- Array functions +------------------------------------------------------------------------------ + +--! @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; + + RAISE 'cannot get array length of a non-array'; + END; +$$ 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 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 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; + + meta := eql_v3.meta_data(val); + sv := eql_v3.ste_vec(val); + + FOR idx IN 1..array_length(sv, 1) LOOP + item = sv[idx]; + RETURN NEXT (meta || item)::eql_v3.jsonb_entry; + END LOOP; + + RETURN; + END; +$$ LANGUAGE plpgsql; + +--! @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; + + sv := eql_v3.ste_vec(val); + + FOR idx IN 1..array_length(sv, 1) LOOP + RETURN NEXT eql_v3.ciphertext(sv[idx]); + END LOOP; + + RETURN; + END; +$$ LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE +-- Source is src/v3/version.template + +DROP FUNCTION IF EXISTS eql_v3.version(); + +--! @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-alpha.2 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. + +--! @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 +--! -- Check installed EQL version +--! SELECT eql_v3.version(); +--! -- Returns: '3.0.0' +CREATE FUNCTION eql_v3.version() + RETURNS text + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT '3.0.0-alpha.2'; +$$ 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-alpha.2'; + +--! @file v3/sem/ore_cllw/operator_class.sql +--! @brief Btree operator class on the eql_v3_internal.ore_cllw composite type. +--! +--! DEFAULT FOR TYPE so a functional btree index on eql_v3_internal.ore_cllw(expr) +--! engages without an explicit opclass annotation. FUNCTION 1 is the three-way +--! comparator btree's internal sort uses; it is plpgsql by design (per-byte +--! CLLW protocol needs iteration) and is called once per index-entry pair +--! during build / search, not per-row in the outer query. +--! +--! @note Excluded from the Supabase build variant by the build glob +--! `**/*operator_class.sql`. +--! @see eql_v3_internal.compare_ore_cllw_term + +CREATE OPERATOR FAMILY eql_v3_internal.ore_cllw_ops USING btree; + +CREATE OPERATOR CLASS eql_v3_internal.ore_cllw_ops + DEFAULT FOR TYPE eql_v3_internal.ore_cllw + USING btree FAMILY eql_v3_internal.ore_cllw_ops AS + OPERATOR 1 public.< (eql_v3_internal.ore_cllw, eql_v3_internal.ore_cllw), + OPERATOR 2 public.<= (eql_v3_internal.ore_cllw, eql_v3_internal.ore_cllw), + OPERATOR 3 public.= (eql_v3_internal.ore_cllw, eql_v3_internal.ore_cllw), + OPERATOR 4 public.>= (eql_v3_internal.ore_cllw, eql_v3_internal.ore_cllw), + OPERATOR 5 public.> (eql_v3_internal.ore_cllw, eql_v3_internal.ore_cllw), + FUNCTION 1 eql_v3_internal.compare_ore_cllw_term(eql_v3_internal.ore_cllw, eql_v3_internal.ore_cllw); + +--! @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_internal.ord_term(col))` engages without +--! an explicit opclass annotation (design D4). Excluded from the Supabase build +--! variant by the `**/*operator_class.sql` glob. + +--! @brief B-tree operator family for ORE block types +CREATE OPERATOR FAMILY eql_v3_internal.ore_block_256_operator_family USING btree; + +--! @brief B-tree operator class for ORE block encrypted values +--! +--! Supports operators: <, <=, =, >=, >. Uses comparison function +--! compare_ore_block_256_terms. +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); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ore_aggregates.sql +--! @brief Aggregates for eql_v3.timestamp_ord_ore. + +--! @brief State function for min on eql_v3.timestamp_ord_ore. +--! @param state eql_v3.timestamp_ord_ore +--! @param value eql_v3.timestamp_ord_ore +--! @return eql_v3.timestamp_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.timestamp_ord_ore, value eql_v3.timestamp_ord_ore) +RETURNS 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; +$$; + +--! @brief min aggregate for eql_v3.timestamp_ord_ore. +--! @param input eql_v3.timestamp_ord_ore +--! @return eql_v3.timestamp_ord_ore +CREATE AGGREGATE eql_v3.min(eql_v3.timestamp_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.timestamp_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.timestamp_ord_ore. +--! @param state eql_v3.timestamp_ord_ore +--! @param value eql_v3.timestamp_ord_ore +--! @return eql_v3.timestamp_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.timestamp_ord_ore, value eql_v3.timestamp_ord_ore) +RETURNS 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; +$$; + +--! @brief max aggregate for eql_v3.timestamp_ord_ore. +--! @param input eql_v3.timestamp_ord_ore +--! @return eql_v3.timestamp_ord_ore +CREATE AGGREGATE eql_v3.max(eql_v3.timestamp_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.timestamp_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ope_aggregates.sql +--! @brief Aggregates for eql_v3.timestamp_ord_ope. + +--! @brief State function for min on eql_v3.timestamp_ord_ope. +--! @param state eql_v3.timestamp_ord_ope +--! @param value eql_v3.timestamp_ord_ope +--! @return eql_v3.timestamp_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.timestamp_ord_ope, value eql_v3.timestamp_ord_ope) +RETURNS 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; +$$; + +--! @brief min aggregate for eql_v3.timestamp_ord_ope. +--! @param input eql_v3.timestamp_ord_ope +--! @return eql_v3.timestamp_ord_ope +CREATE AGGREGATE eql_v3.min(eql_v3.timestamp_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.timestamp_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.timestamp_ord_ope. +--! @param state eql_v3.timestamp_ord_ope +--! @param value eql_v3.timestamp_ord_ope +--! @return eql_v3.timestamp_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.timestamp_ord_ope, value eql_v3.timestamp_ord_ope) +RETURNS 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; +$$; + +--! @brief max aggregate for eql_v3.timestamp_ord_ope. +--! @param input eql_v3.timestamp_ord_ope +--! @return eql_v3.timestamp_ord_ope +CREATE AGGREGATE eql_v3.max(eql_v3.timestamp_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.timestamp_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_aggregates.sql +--! @brief Aggregates for eql_v3.timestamp_ord. + +--! @brief State function for min on eql_v3.timestamp_ord. +--! @param state eql_v3.timestamp_ord +--! @param value eql_v3.timestamp_ord +--! @return eql_v3.timestamp_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.timestamp_ord, value eql_v3.timestamp_ord) +RETURNS eql_v3.timestamp_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 eql_v3.timestamp_ord. +--! @param input eql_v3.timestamp_ord +--! @return eql_v3.timestamp_ord +CREATE AGGREGATE eql_v3.min(eql_v3.timestamp_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.timestamp_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.timestamp_ord. +--! @param state eql_v3.timestamp_ord +--! @param value eql_v3.timestamp_ord +--! @return eql_v3.timestamp_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.timestamp_ord, value eql_v3.timestamp_ord) +RETURNS eql_v3.timestamp_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 eql_v3.timestamp_ord. +--! @param input eql_v3.timestamp_ord +--! @return eql_v3.timestamp_ord +CREATE AGGREGATE eql_v3.max(eql_v3.timestamp_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.timestamp_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_operators.sql +--! @brief Operators for eql_v3.timestamp. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.timestamp, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.timestamp, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.timestamp, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.timestamp, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.timestamp, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.timestamp, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.timestamp, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.timestamp, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.timestamp, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.timestamp, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.timestamp, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.timestamp, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.timestamp, RIGHTARG = eql_v3.timestamp +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_eq_operators.sql +--! @brief Operators for eql_v3.timestamp_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = eql_v3.timestamp_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.timestamp_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.timestamp_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_search_aggregates.sql +--! @brief Aggregates for eql_v3.text_search. + +--! @brief State function for min on eql_v3.text_search. +--! @param state eql_v3.text_search +--! @param value eql_v3.text_search +--! @return eql_v3.text_search +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.text_search, value eql_v3.text_search) +RETURNS 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 min aggregate for eql_v3.text_search. +--! @param input eql_v3.text_search +--! @return eql_v3.text_search +CREATE AGGREGATE eql_v3.min(eql_v3.text_search) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.text_search, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.text_search. +--! @param state eql_v3.text_search +--! @param value eql_v3.text_search +--! @return eql_v3.text_search +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.text_search, value eql_v3.text_search) +RETURNS 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 max aggregate for eql_v3.text_search. +--! @param input eql_v3.text_search +--! @return eql_v3.text_search +CREATE AGGREGATE eql_v3.max(eql_v3.text_search) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.text_search, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ore_aggregates.sql +--! @brief Aggregates for eql_v3.text_ord_ore. + +--! @brief State function for min on eql_v3.text_ord_ore. +--! @param state eql_v3.text_ord_ore +--! @param value eql_v3.text_ord_ore +--! @return eql_v3.text_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.text_ord_ore, value eql_v3.text_ord_ore) +RETURNS 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 eql_v3.text_ord_ore. +--! @param input eql_v3.text_ord_ore +--! @return eql_v3.text_ord_ore +CREATE AGGREGATE eql_v3.min(eql_v3.text_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.text_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.text_ord_ore. +--! @param state eql_v3.text_ord_ore +--! @param value eql_v3.text_ord_ore +--! @return eql_v3.text_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.text_ord_ore, value eql_v3.text_ord_ore) +RETURNS 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 eql_v3.text_ord_ore. +--! @param input eql_v3.text_ord_ore +--! @return eql_v3.text_ord_ore +CREATE AGGREGATE eql_v3.max(eql_v3.text_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.text_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ope_aggregates.sql +--! @brief Aggregates for eql_v3.text_ord_ope. + +--! @brief State function for min on eql_v3.text_ord_ope. +--! @param state eql_v3.text_ord_ope +--! @param value eql_v3.text_ord_ope +--! @return eql_v3.text_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.text_ord_ope, value eql_v3.text_ord_ope) +RETURNS eql_v3.text_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 eql_v3.text_ord_ope. +--! @param input eql_v3.text_ord_ope +--! @return eql_v3.text_ord_ope +CREATE AGGREGATE eql_v3.min(eql_v3.text_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.text_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.text_ord_ope. +--! @param state eql_v3.text_ord_ope +--! @param value eql_v3.text_ord_ope +--! @return eql_v3.text_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.text_ord_ope, value eql_v3.text_ord_ope) +RETURNS eql_v3.text_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 eql_v3.text_ord_ope. +--! @param input eql_v3.text_ord_ope +--! @return eql_v3.text_ord_ope +CREATE AGGREGATE eql_v3.max(eql_v3.text_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.text_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_aggregates.sql +--! @brief Aggregates for eql_v3.text_ord. + +--! @brief State function for min on eql_v3.text_ord. +--! @param state eql_v3.text_ord +--! @param value eql_v3.text_ord +--! @return eql_v3.text_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.text_ord, value eql_v3.text_ord) +RETURNS 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 eql_v3.text_ord. +--! @param input eql_v3.text_ord +--! @return eql_v3.text_ord +CREATE AGGREGATE eql_v3.min(eql_v3.text_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.text_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.text_ord. +--! @param state eql_v3.text_ord +--! @param value eql_v3.text_ord +--! @return eql_v3.text_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.text_ord, value eql_v3.text_ord) +RETURNS 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 eql_v3.text_ord. +--! @param input eql_v3.text_ord +--! @return eql_v3.text_ord +CREATE AGGREGATE eql_v3.max(eql_v3.text_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.text_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_operators.sql +--! @brief Operators for eql_v3.text. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.text, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.text, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.text, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.text, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.text, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.text, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.text, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.text, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.text, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.text, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.text, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.text, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.text, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.text, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.text, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.text, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text, RIGHTARG = eql_v3.text +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.text +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_match_operators.sql +--! @brief Operators for eql_v3.text_match. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.text_match, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.text_match, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.text_match, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.text_match, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.text_match, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.text_match, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = eql_v3.text_match, RIGHTARG = jsonb, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_match, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = eql_v3.text_match, RIGHTARG = jsonb, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_match, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text_match, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text_match, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text_match, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text_match, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.text_match, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.text_match, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.text_match, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.text_match, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.text_match, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.text_match, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.text_match, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_match, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_match, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_match, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.text_match, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text_match, RIGHTARG = eql_v3.text_match +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text_match, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_match +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_eq_operators.sql +--! @brief Operators for eql_v3.text_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.text_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.text_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.text_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text_eq, RIGHTARG = eql_v3.text_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.text_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ore_aggregates.sql +--! @brief Aggregates for eql_v3.smallint_ord_ore. + +--! @brief State function for min on eql_v3.smallint_ord_ore. +--! @param state eql_v3.smallint_ord_ore +--! @param value eql_v3.smallint_ord_ore +--! @return eql_v3.smallint_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.smallint_ord_ore, value eql_v3.smallint_ord_ore) +RETURNS 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 eql_v3.smallint_ord_ore. +--! @param input eql_v3.smallint_ord_ore +--! @return eql_v3.smallint_ord_ore +CREATE AGGREGATE eql_v3.min(eql_v3.smallint_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.smallint_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.smallint_ord_ore. +--! @param state eql_v3.smallint_ord_ore +--! @param value eql_v3.smallint_ord_ore +--! @return eql_v3.smallint_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.smallint_ord_ore, value eql_v3.smallint_ord_ore) +RETURNS 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 eql_v3.smallint_ord_ore. +--! @param input eql_v3.smallint_ord_ore +--! @return eql_v3.smallint_ord_ore +CREATE AGGREGATE eql_v3.max(eql_v3.smallint_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = 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 eql_v3.smallint_ord_ope. + +--! @brief State function for min on eql_v3.smallint_ord_ope. +--! @param state eql_v3.smallint_ord_ope +--! @param value eql_v3.smallint_ord_ope +--! @return eql_v3.smallint_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.smallint_ord_ope, value eql_v3.smallint_ord_ope) +RETURNS 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 min aggregate for eql_v3.smallint_ord_ope. +--! @param input eql_v3.smallint_ord_ope +--! @return eql_v3.smallint_ord_ope +CREATE AGGREGATE eql_v3.min(eql_v3.smallint_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.smallint_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.smallint_ord_ope. +--! @param state eql_v3.smallint_ord_ope +--! @param value eql_v3.smallint_ord_ope +--! @return eql_v3.smallint_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.smallint_ord_ope, value eql_v3.smallint_ord_ope) +RETURNS 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 max aggregate for eql_v3.smallint_ord_ope. +--! @param input eql_v3.smallint_ord_ope +--! @return eql_v3.smallint_ord_ope +CREATE AGGREGATE eql_v3.max(eql_v3.smallint_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.smallint_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_aggregates.sql +--! @brief Aggregates for eql_v3.smallint_ord. + +--! @brief State function for min on eql_v3.smallint_ord. +--! @param state eql_v3.smallint_ord +--! @param value eql_v3.smallint_ord +--! @return eql_v3.smallint_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.smallint_ord, value eql_v3.smallint_ord) +RETURNS 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 min aggregate for eql_v3.smallint_ord. +--! @param input eql_v3.smallint_ord +--! @return eql_v3.smallint_ord +CREATE AGGREGATE eql_v3.min(eql_v3.smallint_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.smallint_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.smallint_ord. +--! @param state eql_v3.smallint_ord +--! @param value eql_v3.smallint_ord +--! @return eql_v3.smallint_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.smallint_ord, value eql_v3.smallint_ord) +RETURNS 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 max aggregate for eql_v3.smallint_ord. +--! @param input eql_v3.smallint_ord +--! @return eql_v3.smallint_ord +CREATE AGGREGATE eql_v3.max(eql_v3.smallint_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.smallint_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_operators.sql +--! @brief Operators for eql_v3.smallint. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.smallint, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.smallint, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.smallint, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.smallint, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.smallint, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.smallint, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.smallint, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.smallint, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.smallint, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.smallint, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.smallint, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.smallint, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.smallint, RIGHTARG = eql_v3.smallint +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_eq_operators.sql +--! @brief Operators for eql_v3.smallint_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = eql_v3.smallint_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.smallint_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ore_aggregates.sql +--! @brief Aggregates for eql_v3.real_ord_ore. + +--! @brief State function for min on eql_v3.real_ord_ore. +--! @param state eql_v3.real_ord_ore +--! @param value eql_v3.real_ord_ore +--! @return eql_v3.real_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.real_ord_ore, value eql_v3.real_ord_ore) +RETURNS 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 min aggregate for eql_v3.real_ord_ore. +--! @param input eql_v3.real_ord_ore +--! @return eql_v3.real_ord_ore +CREATE AGGREGATE eql_v3.min(eql_v3.real_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.real_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.real_ord_ore. +--! @param state eql_v3.real_ord_ore +--! @param value eql_v3.real_ord_ore +--! @return eql_v3.real_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.real_ord_ore, value eql_v3.real_ord_ore) +RETURNS 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 max aggregate for eql_v3.real_ord_ore. +--! @param input eql_v3.real_ord_ore +--! @return eql_v3.real_ord_ore +CREATE AGGREGATE eql_v3.max(eql_v3.real_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.real_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ope_aggregates.sql +--! @brief Aggregates for eql_v3.real_ord_ope. + +--! @brief State function for min on eql_v3.real_ord_ope. +--! @param state eql_v3.real_ord_ope +--! @param value eql_v3.real_ord_ope +--! @return eql_v3.real_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.real_ord_ope, value eql_v3.real_ord_ope) +RETURNS 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 min aggregate for eql_v3.real_ord_ope. +--! @param input eql_v3.real_ord_ope +--! @return eql_v3.real_ord_ope +CREATE AGGREGATE eql_v3.min(eql_v3.real_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.real_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.real_ord_ope. +--! @param state eql_v3.real_ord_ope +--! @param value eql_v3.real_ord_ope +--! @return eql_v3.real_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.real_ord_ope, value eql_v3.real_ord_ope) +RETURNS 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 max aggregate for eql_v3.real_ord_ope. +--! @param input eql_v3.real_ord_ope +--! @return eql_v3.real_ord_ope +CREATE AGGREGATE eql_v3.max(eql_v3.real_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.real_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_aggregates.sql +--! @brief Aggregates for eql_v3.real_ord. + +--! @brief State function for min on eql_v3.real_ord. +--! @param state eql_v3.real_ord +--! @param value eql_v3.real_ord +--! @return eql_v3.real_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.real_ord, value eql_v3.real_ord) +RETURNS 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 min aggregate for eql_v3.real_ord. +--! @param input eql_v3.real_ord +--! @return eql_v3.real_ord +CREATE AGGREGATE eql_v3.min(eql_v3.real_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.real_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.real_ord. +--! @param state eql_v3.real_ord +--! @param value eql_v3.real_ord +--! @return eql_v3.real_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.real_ord, value eql_v3.real_ord) +RETURNS 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 max aggregate for eql_v3.real_ord. +--! @param input eql_v3.real_ord +--! @return eql_v3.real_ord +CREATE AGGREGATE eql_v3.max(eql_v3.real_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.real_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_operators.sql +--! @brief Operators for eql_v3.real. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.real, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.real, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.real, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.real, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.real, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.real, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.real, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.real, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.real, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.real, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.real, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.real, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.real, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.real, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.real, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.real, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.real, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.real, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.real, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.real, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.real, RIGHTARG = eql_v3.real +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.real, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.real +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_eq_operators.sql +--! @brief Operators for eql_v3.real_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.real_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.real_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.real_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.real_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.real_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.real_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.real_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.real_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.real_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.real_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.real_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.real_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.real_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.real_eq, RIGHTARG = eql_v3.real_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.real_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.real_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ore_aggregates.sql +--! @brief Aggregates for eql_v3.numeric_ord_ore. + +--! @brief State function for min on eql_v3.numeric_ord_ore. +--! @param state eql_v3.numeric_ord_ore +--! @param value eql_v3.numeric_ord_ore +--! @return eql_v3.numeric_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.numeric_ord_ore, value eql_v3.numeric_ord_ore) +RETURNS 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 eql_v3.numeric_ord_ore. +--! @param input eql_v3.numeric_ord_ore +--! @return eql_v3.numeric_ord_ore +CREATE AGGREGATE eql_v3.min(eql_v3.numeric_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.numeric_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.numeric_ord_ore. +--! @param state eql_v3.numeric_ord_ore +--! @param value eql_v3.numeric_ord_ore +--! @return eql_v3.numeric_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.numeric_ord_ore, value eql_v3.numeric_ord_ore) +RETURNS 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 eql_v3.numeric_ord_ore. +--! @param input eql_v3.numeric_ord_ore +--! @return eql_v3.numeric_ord_ore +CREATE AGGREGATE eql_v3.max(eql_v3.numeric_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = 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 eql_v3.numeric_ord_ope. + +--! @brief State function for min on eql_v3.numeric_ord_ope. +--! @param state eql_v3.numeric_ord_ope +--! @param value eql_v3.numeric_ord_ope +--! @return eql_v3.numeric_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.numeric_ord_ope, value eql_v3.numeric_ord_ope) +RETURNS 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 eql_v3.numeric_ord_ope. +--! @param input eql_v3.numeric_ord_ope +--! @return eql_v3.numeric_ord_ope +CREATE AGGREGATE eql_v3.min(eql_v3.numeric_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.numeric_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.numeric_ord_ope. +--! @param state eql_v3.numeric_ord_ope +--! @param value eql_v3.numeric_ord_ope +--! @return eql_v3.numeric_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.numeric_ord_ope, value eql_v3.numeric_ord_ope) +RETURNS 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 eql_v3.numeric_ord_ope. +--! @param input eql_v3.numeric_ord_ope +--! @return eql_v3.numeric_ord_ope +CREATE AGGREGATE eql_v3.max(eql_v3.numeric_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.numeric_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_aggregates.sql +--! @brief Aggregates for eql_v3.numeric_ord. + +--! @brief State function for min on eql_v3.numeric_ord. +--! @param state eql_v3.numeric_ord +--! @param value eql_v3.numeric_ord +--! @return eql_v3.numeric_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.numeric_ord, value eql_v3.numeric_ord) +RETURNS 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 min aggregate for eql_v3.numeric_ord. +--! @param input eql_v3.numeric_ord +--! @return eql_v3.numeric_ord +CREATE AGGREGATE eql_v3.min(eql_v3.numeric_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.numeric_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.numeric_ord. +--! @param state eql_v3.numeric_ord +--! @param value eql_v3.numeric_ord +--! @return eql_v3.numeric_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.numeric_ord, value eql_v3.numeric_ord) +RETURNS 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 max aggregate for eql_v3.numeric_ord. +--! @param input eql_v3.numeric_ord +--! @return eql_v3.numeric_ord +CREATE AGGREGATE eql_v3.max(eql_v3.numeric_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.numeric_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_operators.sql +--! @brief Operators for eql_v3.numeric. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.numeric, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.numeric, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.numeric, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.numeric, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.numeric, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.numeric, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.numeric, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.numeric, RIGHTARG = eql_v3.numeric +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_eq_operators.sql +--! @brief Operators for eql_v3.numeric_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = eql_v3.numeric_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.numeric_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ore_aggregates.sql +--! @brief Aggregates for eql_v3.integer_ord_ore. + +--! @brief State function for min on eql_v3.integer_ord_ore. +--! @param state eql_v3.integer_ord_ore +--! @param value eql_v3.integer_ord_ore +--! @return eql_v3.integer_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.integer_ord_ore, value eql_v3.integer_ord_ore) +RETURNS 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 min aggregate for eql_v3.integer_ord_ore. +--! @param input eql_v3.integer_ord_ore +--! @return eql_v3.integer_ord_ore +CREATE AGGREGATE eql_v3.min(eql_v3.integer_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.integer_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.integer_ord_ore. +--! @param state eql_v3.integer_ord_ore +--! @param value eql_v3.integer_ord_ore +--! @return eql_v3.integer_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.integer_ord_ore, value eql_v3.integer_ord_ore) +RETURNS 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 max aggregate for eql_v3.integer_ord_ore. +--! @param input eql_v3.integer_ord_ore +--! @return eql_v3.integer_ord_ore +CREATE AGGREGATE eql_v3.max(eql_v3.integer_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.integer_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ope_aggregates.sql +--! @brief Aggregates for eql_v3.integer_ord_ope. + +--! @brief State function for min on eql_v3.integer_ord_ope. +--! @param state eql_v3.integer_ord_ope +--! @param value eql_v3.integer_ord_ope +--! @return eql_v3.integer_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.integer_ord_ope, value eql_v3.integer_ord_ope) +RETURNS 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 min aggregate for eql_v3.integer_ord_ope. +--! @param input eql_v3.integer_ord_ope +--! @return eql_v3.integer_ord_ope +CREATE AGGREGATE eql_v3.min(eql_v3.integer_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.integer_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.integer_ord_ope. +--! @param state eql_v3.integer_ord_ope +--! @param value eql_v3.integer_ord_ope +--! @return eql_v3.integer_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.integer_ord_ope, value eql_v3.integer_ord_ope) +RETURNS 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 max aggregate for eql_v3.integer_ord_ope. +--! @param input eql_v3.integer_ord_ope +--! @return eql_v3.integer_ord_ope +CREATE AGGREGATE eql_v3.max(eql_v3.integer_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.integer_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_aggregates.sql +--! @brief Aggregates for eql_v3.integer_ord. + +--! @brief State function for min on eql_v3.integer_ord. +--! @param state eql_v3.integer_ord +--! @param value eql_v3.integer_ord +--! @return eql_v3.integer_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.integer_ord, value eql_v3.integer_ord) +RETURNS 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 min aggregate for eql_v3.integer_ord. +--! @param input eql_v3.integer_ord +--! @return eql_v3.integer_ord +CREATE AGGREGATE eql_v3.min(eql_v3.integer_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.integer_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.integer_ord. +--! @param state eql_v3.integer_ord +--! @param value eql_v3.integer_ord +--! @return eql_v3.integer_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.integer_ord, value eql_v3.integer_ord) +RETURNS 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 max aggregate for eql_v3.integer_ord. +--! @param input eql_v3.integer_ord +--! @return eql_v3.integer_ord +CREATE AGGREGATE eql_v3.max(eql_v3.integer_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.integer_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_operators.sql +--! @brief Operators for eql_v3.integer. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.integer, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.integer, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.integer, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.integer, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.integer, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.integer, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.integer, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.integer, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.integer, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.integer, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.integer, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.integer, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.integer, RIGHTARG = eql_v3.integer +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_eq_operators.sql +--! @brief Operators for eql_v3.integer_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.integer_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.integer_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.integer_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.integer_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.integer_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.integer_eq, RIGHTARG = eql_v3.integer_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.integer_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ore_aggregates.sql +--! @brief Aggregates for eql_v3.double_ord_ore. + +--! @brief State function for min on eql_v3.double_ord_ore. +--! @param state eql_v3.double_ord_ore +--! @param value eql_v3.double_ord_ore +--! @return eql_v3.double_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.double_ord_ore, value eql_v3.double_ord_ore) +RETURNS 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; +$$; + +--! @brief min aggregate for eql_v3.double_ord_ore. +--! @param input eql_v3.double_ord_ore +--! @return eql_v3.double_ord_ore +CREATE AGGREGATE eql_v3.min(eql_v3.double_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.double_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.double_ord_ore. +--! @param state eql_v3.double_ord_ore +--! @param value eql_v3.double_ord_ore +--! @return eql_v3.double_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.double_ord_ore, value eql_v3.double_ord_ore) +RETURNS 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; +$$; + +--! @brief max aggregate for eql_v3.double_ord_ore. +--! @param input eql_v3.double_ord_ore +--! @return eql_v3.double_ord_ore +CREATE AGGREGATE eql_v3.max(eql_v3.double_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.double_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ope_aggregates.sql +--! @brief Aggregates for eql_v3.double_ord_ope. + +--! @brief State function for min on eql_v3.double_ord_ope. +--! @param state eql_v3.double_ord_ope +--! @param value eql_v3.double_ord_ope +--! @return eql_v3.double_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.double_ord_ope, value eql_v3.double_ord_ope) +RETURNS eql_v3.double_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 eql_v3.double_ord_ope. +--! @param input eql_v3.double_ord_ope +--! @return eql_v3.double_ord_ope +CREATE AGGREGATE eql_v3.min(eql_v3.double_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.double_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.double_ord_ope. +--! @param state eql_v3.double_ord_ope +--! @param value eql_v3.double_ord_ope +--! @return eql_v3.double_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.double_ord_ope, value eql_v3.double_ord_ope) +RETURNS eql_v3.double_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 eql_v3.double_ord_ope. +--! @param input eql_v3.double_ord_ope +--! @return eql_v3.double_ord_ope +CREATE AGGREGATE eql_v3.max(eql_v3.double_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.double_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_aggregates.sql +--! @brief Aggregates for eql_v3.double_ord. + +--! @brief State function for min on eql_v3.double_ord. +--! @param state eql_v3.double_ord +--! @param value eql_v3.double_ord +--! @return eql_v3.double_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.double_ord, value eql_v3.double_ord) +RETURNS 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 min aggregate for eql_v3.double_ord. +--! @param input eql_v3.double_ord +--! @return eql_v3.double_ord +CREATE AGGREGATE eql_v3.min(eql_v3.double_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.double_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.double_ord. +--! @param state eql_v3.double_ord +--! @param value eql_v3.double_ord +--! @return eql_v3.double_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.double_ord, value eql_v3.double_ord) +RETURNS 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 eql_v3.double_ord. +--! @param input eql_v3.double_ord +--! @return eql_v3.double_ord +CREATE AGGREGATE eql_v3.max(eql_v3.double_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.double_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_operators.sql +--! @brief Operators for eql_v3.double. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.double, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.double, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.double, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.double, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.double, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.double, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.double, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.double, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.double, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.double, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.double, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.double, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.double, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.double, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.double, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.double, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.double, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.double, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.double, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.double, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.double, RIGHTARG = eql_v3.double +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.double, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.double +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_eq_operators.sql +--! @brief Operators for eql_v3.double_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.double_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.double_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.double_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.double_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.double_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.double_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.double_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.double_eq, RIGHTARG = eql_v3.double_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.double_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ore_aggregates.sql +--! @brief Aggregates for eql_v3.date_ord_ore. + +--! @brief State function for min on eql_v3.date_ord_ore. +--! @param state eql_v3.date_ord_ore +--! @param value eql_v3.date_ord_ore +--! @return eql_v3.date_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.date_ord_ore, value eql_v3.date_ord_ore) +RETURNS 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 min aggregate for eql_v3.date_ord_ore. +--! @param input eql_v3.date_ord_ore +--! @return eql_v3.date_ord_ore +CREATE AGGREGATE eql_v3.min(eql_v3.date_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.date_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.date_ord_ore. +--! @param state eql_v3.date_ord_ore +--! @param value eql_v3.date_ord_ore +--! @return eql_v3.date_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.date_ord_ore, value eql_v3.date_ord_ore) +RETURNS 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 max aggregate for eql_v3.date_ord_ore. +--! @param input eql_v3.date_ord_ore +--! @return eql_v3.date_ord_ore +CREATE AGGREGATE eql_v3.max(eql_v3.date_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.date_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ope_aggregates.sql +--! @brief Aggregates for eql_v3.date_ord_ope. + +--! @brief State function for min on eql_v3.date_ord_ope. +--! @param state eql_v3.date_ord_ope +--! @param value eql_v3.date_ord_ope +--! @return eql_v3.date_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.date_ord_ope, value eql_v3.date_ord_ope) +RETURNS 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 min aggregate for eql_v3.date_ord_ope. +--! @param input eql_v3.date_ord_ope +--! @return eql_v3.date_ord_ope +CREATE AGGREGATE eql_v3.min(eql_v3.date_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.date_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.date_ord_ope. +--! @param state eql_v3.date_ord_ope +--! @param value eql_v3.date_ord_ope +--! @return eql_v3.date_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.date_ord_ope, value eql_v3.date_ord_ope) +RETURNS 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 max aggregate for eql_v3.date_ord_ope. +--! @param input eql_v3.date_ord_ope +--! @return eql_v3.date_ord_ope +CREATE AGGREGATE eql_v3.max(eql_v3.date_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.date_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_aggregates.sql +--! @brief Aggregates for eql_v3.date_ord. + +--! @brief State function for min on eql_v3.date_ord. +--! @param state eql_v3.date_ord +--! @param value eql_v3.date_ord +--! @return eql_v3.date_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.date_ord, value eql_v3.date_ord) +RETURNS 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 min aggregate for eql_v3.date_ord. +--! @param input eql_v3.date_ord +--! @return eql_v3.date_ord +CREATE AGGREGATE eql_v3.min(eql_v3.date_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.date_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.date_ord. +--! @param state eql_v3.date_ord +--! @param value eql_v3.date_ord +--! @return eql_v3.date_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.date_ord, value eql_v3.date_ord) +RETURNS 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 max aggregate for eql_v3.date_ord. +--! @param input eql_v3.date_ord +--! @return eql_v3.date_ord +CREATE AGGREGATE eql_v3.max(eql_v3.date_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.date_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_operators.sql +--! @brief Operators for eql_v3.date. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.date, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.date, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.date, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.date, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.date, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.date, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.date, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.date, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.date, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.date, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.date, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.date, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.date, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.date, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.date, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.date, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.date, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.date, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.date, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.date, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.date, RIGHTARG = eql_v3.date +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.date, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.date +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_eq_operators.sql +--! @brief Operators for eql_v3.date_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.date_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.date_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.date_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.date_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.date_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.date_eq, RIGHTARG = eql_v3.date_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.date_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/boolean/boolean_operators.sql +--! @brief Operators for eql_v3.boolean. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.boolean, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.boolean, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.boolean, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.boolean, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.boolean, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.boolean, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.boolean, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.boolean, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.boolean, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.boolean, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.boolean, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.boolean, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.boolean, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.boolean, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.boolean, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.boolean, RIGHTARG = eql_v3.boolean +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.boolean +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ore_aggregates.sql +--! @brief Aggregates for eql_v3.bigint_ord_ore. + +--! @brief State function for min on eql_v3.bigint_ord_ore. +--! @param state eql_v3.bigint_ord_ore +--! @param value eql_v3.bigint_ord_ore +--! @return eql_v3.bigint_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.bigint_ord_ore, value eql_v3.bigint_ord_ore) +RETURNS 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 eql_v3.bigint_ord_ore. +--! @param input eql_v3.bigint_ord_ore +--! @return eql_v3.bigint_ord_ore +CREATE AGGREGATE eql_v3.min(eql_v3.bigint_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.bigint_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.bigint_ord_ore. +--! @param state eql_v3.bigint_ord_ore +--! @param value eql_v3.bigint_ord_ore +--! @return eql_v3.bigint_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.bigint_ord_ore, value eql_v3.bigint_ord_ore) +RETURNS 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 eql_v3.bigint_ord_ore. +--! @param input eql_v3.bigint_ord_ore +--! @return eql_v3.bigint_ord_ore +CREATE AGGREGATE eql_v3.max(eql_v3.bigint_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = 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 eql_v3.bigint_ord_ope. + +--! @brief State function for min on eql_v3.bigint_ord_ope. +--! @param state eql_v3.bigint_ord_ope +--! @param value eql_v3.bigint_ord_ope +--! @return eql_v3.bigint_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.bigint_ord_ope, value eql_v3.bigint_ord_ope) +RETURNS 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 eql_v3.bigint_ord_ope. +--! @param input eql_v3.bigint_ord_ope +--! @return eql_v3.bigint_ord_ope +CREATE AGGREGATE eql_v3.min(eql_v3.bigint_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.bigint_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.bigint_ord_ope. +--! @param state eql_v3.bigint_ord_ope +--! @param value eql_v3.bigint_ord_ope +--! @return eql_v3.bigint_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.bigint_ord_ope, value eql_v3.bigint_ord_ope) +RETURNS 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 eql_v3.bigint_ord_ope. +--! @param input eql_v3.bigint_ord_ope +--! @return eql_v3.bigint_ord_ope +CREATE AGGREGATE eql_v3.max(eql_v3.bigint_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = 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 eql_v3.bigint_ord. + +--! @brief State function for min on eql_v3.bigint_ord. +--! @param state eql_v3.bigint_ord +--! @param value eql_v3.bigint_ord +--! @return eql_v3.bigint_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state eql_v3.bigint_ord, value eql_v3.bigint_ord) +RETURNS 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 min aggregate for eql_v3.bigint_ord. +--! @param input eql_v3.bigint_ord +--! @return eql_v3.bigint_ord +CREATE AGGREGATE eql_v3.min(eql_v3.bigint_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = eql_v3.bigint_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.bigint_ord. +--! @param state eql_v3.bigint_ord +--! @param value eql_v3.bigint_ord +--! @return eql_v3.bigint_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state eql_v3.bigint_ord, value eql_v3.bigint_ord) +RETURNS 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 max aggregate for eql_v3.bigint_ord. +--! @param input eql_v3.bigint_ord +--! @return eql_v3.bigint_ord +CREATE AGGREGATE eql_v3.max(eql_v3.bigint_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = eql_v3.bigint_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_operators.sql +--! @brief Operators for eql_v3.bigint. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = eql_v3.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = eql_v3.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.bigint, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.bigint, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.bigint, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.bigint, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.bigint, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.bigint, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.bigint, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.bigint, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.bigint, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.bigint, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.bigint, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.bigint, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.bigint, RIGHTARG = eql_v3.bigint +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_eq_operators.sql +--! @brief Operators for eql_v3.bigint_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = eql_v3.bigint_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = eql_v3.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = eql_v3.bigint_eq +); + +--! @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 types `eql_v3_internal.ore_block_256`, `eql_v3_internal.ore_cllw`) 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 + -- All operators where at least one operand is an `eql_v3` type. 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())) + ) + ), + + -- 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 + ), + + -- 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 `eql_v3` 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 pg_catalog.pg_type dt ON dt.oid = arg.typ + JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace + JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype + WHERE dt.typtype = 'd' + AND bt.typname = 'jsonb' + AND dn.nspname = ANY(eql_v3_internal.owned_schemas()) + ) + ) + + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ 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). │ + -- └─────────────────────────────────────────────────────────────────┘ + + 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 + ) + + UNION ALL + + 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 + ) + + UNION ALL + + 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 + ) + + UNION ALL + + 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 + ) + + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ 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. │ + -- └─────────────────────────────────────────────────────────────────┘ + + UNION ALL + + 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 + ) + + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ 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. │ + -- └─────────────────────────────────────────────────────────────────┘ + + UNION ALL + + 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' + + UNION ALL + + 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 + + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ 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. │ + -- └─────────────────────────────────────────────────────────────────┘ + + UNION ALL + + 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 bn.nspname = ANY(eql_v3_internal.owned_schemas()) + + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ 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. │ + -- └─────────────────────────────────────────────────────────────────┘ + + UNION ALL + + 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.typtype = 'd' + AND tn.nspname = ANY(eql_v3_internal.owned_schemas()) + + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ 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. │ + -- └─────────────────────────────────────────────────────────────────┘ + + UNION ALL + + 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') + + ORDER BY 1, 2, 3; +$$; + +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.'; + +--! @file v3/jsonb/operators.sql +--! @brief Operators on eql_v3.json and eql_v3.jsonb_entry. + +------------------------------------------------------------------------------ +-- -> field accessor (returns jsonb_entry) +------------------------------------------------------------------------------ + +--! @brief -> operator with text selector. +--! +--! Returns the sv entry whose `s` equals @p selector, with root `i`/`v` merged +--! in. Inlinable: `WHERE col -> 'sel' = $1` reduces structurally to +--! `eql_v3.eq_term(col -> 'sel') = eql_v3.eq_term($1)` and matches a functional +--! index on `eql_v3.eq_term(col -> 'sel')`. +--! +--! @warning The selector operand MUST carry a known type — a text-typed +--! 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 `eql_v3.json` +--! 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 eql_v3.json Root encrypted payload. +--! @param selector text Selector hash. +--! @return eql_v3.jsonb_entry Matching entry merged with root meta, or NULL. +CREATE FUNCTION eql_v3."->"(e eql_v3.json, selector text) + RETURNS eql_v3.jsonb_entry + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT ( + eql_v3.meta_data(e) || + jsonb_path_query_first( + e, + '$.sv[*] ? (@.s == $sel)'::jsonpath, + jsonb_build_object('sel', selector) + ) + )::eql_v3.jsonb_entry +$$; + +CREATE OPERATOR ->( + FUNCTION=eql_v3."->", + LEFTARG=eql_v3.json, + RIGHTARG=text +); + +--! @brief -> operator with integer array index (0-based, JSONB convention). +--! @param e eql_v3.json Encrypted sv-array payload. +--! @param selector integer Array index. +--! @return eql_v3.jsonb_entry Matching entry merged with root meta, or NULL. +CREATE FUNCTION eql_v3."->"(e eql_v3.json, selector integer) + RETURNS eql_v3.jsonb_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 `eql_v3.json` to + -- its base type and binds native `jsonb -> text` (see the @warning above) — + -- the custom `->(eql_v3.json, 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 `->(eql_v3.json, integer)` + -- operator instead of native array access. + (eql_v3.meta_data(e) || (e::jsonb -> 'sv' -> selector))::eql_v3.jsonb_entry + ELSE NULL + END +$$; + +CREATE OPERATOR ->( + FUNCTION=eql_v3."->", + LEFTARG=eql_v3.json, + RIGHTARG=integer +); + +------------------------------------------------------------------------------ +-- ->> field accessor (alias of -> coerced to text) +------------------------------------------------------------------------------ + +--! @brief ->> operator with text selector. Inlinable alias of -> coerced to +--! text. +--! +--! 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 eql_v3.json Encrypted payload. +--! @param selector text Field selector hash. +--! @return text The matching entry as text. +CREATE FUNCTION eql_v3."->>"(e eql_v3.json, selector text) + RETURNS text + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3."->"(e, selector)::jsonb::text +$$; + +CREATE OPERATOR ->> ( + FUNCTION=eql_v3."->>", + LEFTARG=eql_v3.json, + RIGHTARG=text +); + +--! @brief ->> operator with integer array index. Inlinable alias of +--! ->(json, integer) coerced to text. +--! @param e eql_v3.json Encrypted sv-array payload. +--! @param selector integer Array index. +--! @return text The matching entry as text. +CREATE FUNCTION eql_v3."->>"(e eql_v3.json, selector integer) + RETURNS text + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3."->"(e, selector)::jsonb::text +$$; + +CREATE OPERATOR ->> ( + FUNCTION=eql_v3."->>", + LEFTARG=eql_v3.json, + RIGHTARG=integer +); + +------------------------------------------------------------------------------ +-- @> containment +------------------------------------------------------------------------------ + +--! @brief @> contains operator (document, document). +--! @param a eql_v3.json Container. +--! @param b eql_v3.json Contained value. +--! @return boolean True if a contains b. +--! @see eql_v3.ste_vec_contains +CREATE FUNCTION eql_v3."@>"(a eql_v3.json, b eql_v3.json) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ste_vec_contains(a, b) +$$; + +CREATE OPERATOR @>( + FUNCTION=eql_v3."@>", + LEFTARG=eql_v3.json, + RIGHTARG=eql_v3.json +); + +--! @brief @> contains operator with an jsonb_query 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 eql_v3.json Container. +--! @param b eql_v3.jsonb_query Query payload. +--! @return boolean True if a contains b. +CREATE FUNCTION eql_v3."@>"(a eql_v3.json, b eql_v3.jsonb_query) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.to_ste_vec_query(a)::jsonb @> b::jsonb +$$; + +CREATE OPERATOR @>( + FUNCTION=eql_v3."@>", + LEFTARG=eql_v3.json, + RIGHTARG=eql_v3.jsonb_query +); + +--! @brief @> contains operator with a single jsonb_entry needle. +--! +--! 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 eql_v3.json Container. +--! @param b eql_v3.jsonb_entry Single entry. +--! @return boolean True if a contains an sv entry matching b. +CREATE FUNCTION eql_v3."@>"(a eql_v3.json, b eql_v3.jsonb_entry) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.to_ste_vec_query(a)::jsonb + @> jsonb_build_object( + 'sv', + jsonb_build_array( + jsonb_strip_nulls( + jsonb_build_object( + 's', b -> 's', + 'hm', b -> 'hm', + 'oc', b -> 'oc' + ) + ) + ) + ) +$$; + +CREATE OPERATOR @>( + FUNCTION=eql_v3."@>", + LEFTARG=eql_v3.json, + RIGHTARG=eql_v3.jsonb_entry +); + +------------------------------------------------------------------------------ +-- <@ contained-by (reverse of @>) +------------------------------------------------------------------------------ + +--! @brief <@ contained-by operator (document, document). +--! @param a eql_v3.json Contained value. +--! @param b eql_v3.json Container. +--! @return boolean True if a is contained by b. +CREATE FUNCTION eql_v3."<@"(a eql_v3.json, b eql_v3.json) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ste_vec_contains(b, a) +$$; + +CREATE OPERATOR <@( + FUNCTION=eql_v3."<@", + LEFTARG=eql_v3.json, + RIGHTARG=eql_v3.json +); + +--! @brief <@ contained-by operator with an jsonb_query LHS. +--! @param a eql_v3.jsonb_query Query payload. +--! @param b eql_v3.json Container. +--! @return boolean True if b contains a. +CREATE FUNCTION eql_v3."<@"(a eql_v3.jsonb_query, b eql_v3.json) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3."@>"(b, a) +$$; + +CREATE OPERATOR <@( + FUNCTION=eql_v3."<@", + LEFTARG=eql_v3.jsonb_query, + RIGHTARG=eql_v3.json +); + +--! @brief <@ contained-by operator with a jsonb_entry LHS. +--! @param a eql_v3.jsonb_entry Single entry. +--! @param b eql_v3.json Container. +--! @return boolean True if b contains a. +CREATE FUNCTION eql_v3."<@"(a eql_v3.jsonb_entry, b eql_v3.json) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3."@>"(b, a) +$$; + +CREATE OPERATOR <@( + FUNCTION=eql_v3."<@", + LEFTARG=eql_v3.jsonb_entry, + RIGHTARG=eql_v3.json +); + +------------------------------------------------------------------------------ +-- jsonb_entry comparisons +------------------------------------------------------------------------------ + +--! @brief Equality on jsonb_entry via eq_term (hm-or-oc byte equality). +--! @param a eql_v3.jsonb_entry Left operand +--! @param b eql_v3.jsonb_entry Right operand +--! @return boolean True if the entries are equal +CREATE FUNCTION eql_v3.eq(a eql_v3.jsonb_entry, b eql_v3.jsonb_entry) + 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.jsonb_entry, + RIGHTARG = eql_v3.jsonb_entry, + COMMUTATOR = =, + NEGATOR = <>, + RESTRICT = eqsel, + JOIN = eqjoinsel +); + +--! @brief Inequality on jsonb_entry via eq_term. +--! @param a eql_v3.jsonb_entry Left operand +--! @param b eql_v3.jsonb_entry Right operand +--! @return boolean True if the entries are not equal +CREATE FUNCTION eql_v3.neq(a eql_v3.jsonb_entry, b eql_v3.jsonb_entry) + 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.jsonb_entry, + RIGHTARG = eql_v3.jsonb_entry, + COMMUTATOR = <>, + NEGATOR = =, + RESTRICT = neqsel, + JOIN = neqjoinsel +); + +--! @brief Less-than on jsonb_entry via ore_cllw. +--! @param a eql_v3.jsonb_entry Left operand +--! @param b eql_v3.jsonb_entry Right operand +--! @return boolean True if a is less than b +CREATE FUNCTION eql_v3.lt(a eql_v3.jsonb_entry, b eql_v3.jsonb_entry) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ore_cllw(a) < eql_v3.ore_cllw(b) +$$; + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = eql_v3.jsonb_entry, + RIGHTARG = eql_v3.jsonb_entry, + COMMUTATOR = >, + NEGATOR = >=, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel +); + +--! @brief Less-than-or-equal on jsonb_entry via ore_cllw. +--! @param a eql_v3.jsonb_entry Left operand +--! @param b eql_v3.jsonb_entry Right operand +--! @return boolean True if a is less than or equal to b +CREATE FUNCTION eql_v3.lte(a eql_v3.jsonb_entry, b eql_v3.jsonb_entry) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ore_cllw(a) <= eql_v3.ore_cllw(b) +$$; + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = eql_v3.jsonb_entry, + RIGHTARG = eql_v3.jsonb_entry, + COMMUTATOR = >=, + NEGATOR = >, + RESTRICT = scalarlesel, + JOIN = scalarlejoinsel +); + +--! @brief Greater-than on jsonb_entry via ore_cllw. +--! @param a eql_v3.jsonb_entry Left operand +--! @param b eql_v3.jsonb_entry Right operand +--! @return boolean True if a is greater than b +CREATE FUNCTION eql_v3.gt(a eql_v3.jsonb_entry, b eql_v3.jsonb_entry) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ore_cllw(a) > eql_v3.ore_cllw(b) +$$; + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = eql_v3.jsonb_entry, + RIGHTARG = eql_v3.jsonb_entry, + COMMUTATOR = <, + NEGATOR = <=, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel +); + +--! @brief Greater-than-or-equal on jsonb_entry via ore_cllw. +--! @param a eql_v3.jsonb_entry Left operand +--! @param b eql_v3.jsonb_entry Right operand +--! @return boolean True if a is greater than or equal to b +CREATE FUNCTION eql_v3.gte(a eql_v3.jsonb_entry, b eql_v3.jsonb_entry) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ore_cllw(a) >= eql_v3.ore_cllw(b) +$$; + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = eql_v3.jsonb_entry, + RIGHTARG = eql_v3.jsonb_entry, + COMMUTATOR = <=, + NEGATOR = <, + RESTRICT = scalargesel, + JOIN = scalargejoinsel +); + +--! @file v3/jsonb/blockers.sql +--! @brief Native-jsonb firewall for eql_v3.json. +--! +--! eql_v3.json SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons +--! = <> < <= > >= are supported on eql_v3.jsonb_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 +--! route to plaintext-jsonb semantics. The blocked set is KNOWN_JSONB_OPERATORS +--! minus the supported ops: ? ?| ?& @? @@ #> #>> - #- ||. +--! +--! Each blocker is LANGUAGE plpgsql (NEVER STRICT — a STRICT blocker would let +--! PostgreSQL skip the body and return NULL on a NULL argument, bypassing the +--! exception) and delegates to the shared eql_v3.encrypted_domain_unsupported_* +--! helpers. Each blocker's RETURNS type matches the native operator it shadows +--! (#> -> jsonb, #>> -> text, - / #- / || -> jsonb; the rest are boolean) so a +--! composed expression resolves and the body raises 'operator not supported', +--! rather than failing earlier with a misleading 'operator does not exist' on a +--! boolean intermediate. The bound operator must resolve before native fallback, +--! so the firewall fires. + +--! @brief Blocker: ? (key/element exists). +--! @param a eql_v3.json 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 eql_v3.json, b text) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '?'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal.jsonb_blocked_exists, + LEFTARG = eql_v3.json, + RIGHTARG = text +); + +--! @brief Blocker: ?| (any key exists). +--! @param a eql_v3.json 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 eql_v3.json, b text[]) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '?|'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal.jsonb_blocked_exists_any, + LEFTARG = eql_v3.json, + RIGHTARG = text[] +); + +--! @brief Blocker: ?& (all keys exist). +--! @param a eql_v3.json 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 eql_v3.json, b text[]) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '?&'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal.jsonb_blocked_exists_all, + LEFTARG = eql_v3.json, + RIGHTARG = text[] +); + +--! @brief Blocker: @? (jsonpath exists). +--! @param a eql_v3.json 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 eql_v3.json, b jsonpath) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '@?'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_exists, + LEFTARG = eql_v3.json, + RIGHTARG = jsonpath +); + +--! @brief Blocker: @@ (jsonpath predicate). +--! @param a eql_v3.json 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 eql_v3.json, b jsonpath) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '@@'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_match, + LEFTARG = eql_v3.json, + RIGHTARG = jsonpath +); + +--! @brief Blocker: #> (path extract, native returns jsonb). +--! @param a eql_v3.json 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 eql_v3.json, b text[]) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '#>'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal.jsonb_blocked_path_extract, + LEFTARG = eql_v3.json, + RIGHTARG = text[] +); + +--! @brief Blocker: #>> (path extract as text). +--! @param a eql_v3.json 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 eql_v3.json, b text[]) +RETURNS text +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_text('eql_v3.json', '#>>'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal.jsonb_blocked_path_extract_text, + LEFTARG = eql_v3.json, + RIGHTARG = text[] +); + +--! @brief Blocker: - (delete key, text RHS; native returns jsonb). +--! @param a eql_v3.json 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 eql_v3.json, b text) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '-'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal.jsonb_blocked_delete_text, + LEFTARG = eql_v3.json, + RIGHTARG = text +); + +--! @brief Blocker: - (delete index, integer RHS). +--! @param a eql_v3.json 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 eql_v3.json, b integer) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '-'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal.jsonb_blocked_delete_int, + LEFTARG = eql_v3.json, + RIGHTARG = integer +); + +--! @brief Blocker: - (delete keys, text[] RHS). +--! @param a eql_v3.json 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 eql_v3.json, b text[]) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '-'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal.jsonb_blocked_delete_array, + LEFTARG = eql_v3.json, + RIGHTARG = text[] +); + +--! @brief Blocker: #- (delete at path). +--! @param a eql_v3.json 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 eql_v3.json, b text[]) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '#-'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal.jsonb_blocked_delete_path, + LEFTARG = eql_v3.json, + RIGHTARG = text[] +); + +--! @brief Blocker: || (concatenate, encrypted on the left). +--! @param a eql_v3.json 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 eql_v3.json, b jsonb) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '||'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal.jsonb_blocked_concat, + LEFTARG = eql_v3.json, + RIGHTARG = jsonb +); + +--! @brief Blocker: || (concatenate, encrypted on the right). +--! @param a jsonb Native LHS operand. +--! @param b eql_v3.json 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 eql_v3.json) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('eql_v3.json', '||'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal.jsonb_blocked_concat_rhs, + LEFTARG = jsonb, + RIGHTARG = eql_v3.json +); + +------------------------------------------------------------------------------ +-- Root-document comparison blockers. +------------------------------------------------------------------------------ + +--! @brief Blocker: root eql_v3.json document comparisons. +--! @param a eql_v3.json Left operand (encrypted payload). +--! @param b eql_v3.json Right operand (encrypted payload). +--! @return boolean Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_json(a eql_v3.json, b eql_v3.json) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', 'comparison'); +END; +$$ LANGUAGE plpgsql; + +--! @brief Blocker: root eql_v3.json-to-jsonb comparisons. +--! @param a eql_v3.json 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 eql_v3.json, b jsonb) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', 'comparison'); +END; +$$ LANGUAGE plpgsql; + +--! @brief Blocker: root jsonb-to-eql_v3.json comparisons. +--! @param a jsonb Native LHS operand. +--! @param b eql_v3.json 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 eql_v3.json) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', 'comparison'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, + LEFTARG = eql_v3.json, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = eql_v3.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, + LEFTARG = eql_v3.json, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = eql_v3.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, + LEFTARG = eql_v3.json, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = eql_v3.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, + LEFTARG = eql_v3.json, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = eql_v3.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, + LEFTARG = eql_v3.json, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = eql_v3.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, + LEFTARG = eql_v3.json, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = eql_v3.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = eql_v3.json +); + +------------------------------------------------------------------------------ +-- Mixed jsonb containment blockers. +------------------------------------------------------------------------------ + +--! @brief Blocker: @> with encrypted root document and native jsonb. +--! @param a eql_v3.json 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 eql_v3.json, b jsonb) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '@>'); +END; +$$ LANGUAGE plpgsql; + +--! @brief Blocker: @> with native jsonb and encrypted root document. +--! @param a jsonb Native LHS operand. +--! @param b eql_v3.json 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 eql_v3.json) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '@>'); +END; +$$ LANGUAGE plpgsql; + +--! @brief Blocker: <@ with encrypted root document and native jsonb. +--! @param a eql_v3.json 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 eql_v3.json, b jsonb) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '<@'); +END; +$$ LANGUAGE plpgsql; + +--! @brief Blocker: <@ with native jsonb and encrypted root document. +--! @param a jsonb Native LHS operand. +--! @param b eql_v3.json 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 eql_v3.json) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('eql_v3.json', '<@'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.jsonb_blocked_contains_json_jsonb, + LEFTARG = eql_v3.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.jsonb_blocked_contains_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = eql_v3.json +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.jsonb_blocked_contained_json_jsonb, + LEFTARG = eql_v3.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.jsonb_blocked_contained_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = eql_v3.json +); + +--! @file v3/jsonb/aggregates.sql +--! @brief min / max aggregates over eql_v3.jsonb_entry. +--! +--! SteVec document entries extracted at a selector (`doc -> 'sel'`) order by +--! their CLLW ORE (`oc`) term, so the extremum is picked by comparing +--! `eql_v3.ore_cllw(entry)` rather than the scalar Block-ORE `ord_term` the +--! generated scalar ord aggregates use. 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 `oc`-carrying entries are orderable.** `eql_v3.ore_cllw(entry)` +--! returns NULL when an entry has no `oc` (CLLW ORE) term — the same entries a +--! `eql_v3.ore_cllw` btree NULL-filters from range scans. The state functions +--! therefore IGNORE `oc`-less entries (they never become or survive as the +--! extremum), so `min`/`max` is well-defined over a mix of `oc`-carrying and +--! `oc`-less entries and is not corrupted by an `oc`-less seed. A naive +--! `ore_cllw(value) < ore_cllw(state)` would be NULL whenever either side +--! lacks `oc`, pinning a wrong (`oc`-less) extremum when the first aggregated +--! row is `oc`-less. An all-`oc`-less input has no orderable extremum and +--! returns the (arbitrary) STRICT seed. + +--! @brief State function for min on eql_v3.jsonb_entry. +--! +--! Keeps whichever orderable entry has the lesser CLLW ORE term. STRICT, so SQL +--! NULL entries are skipped by the aggregate machinery; `oc`-less (non-orderable) +--! entries are skipped explicitly (see the @note on this file). +--! +--! @param state eql_v3.jsonb_entry Running extremum. +--! @param value eql_v3.jsonb_entry Candidate entry. +--! @return eql_v3.jsonb_entry The lesser orderable entry by `ore_cllw`. +CREATE FUNCTION eql_v3_internal.jsonb_entry_min_sfunc( + state eql_v3.jsonb_entry, + value eql_v3.jsonb_entry +) +RETURNS eql_v3.jsonb_entry +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +DECLARE + value_ore eql_v3_internal.ore_cllw := eql_v3.ore_cllw(value); + state_ore eql_v3_internal.ore_cllw := eql_v3.ore_cllw(state); +BEGIN + -- A non-orderable (oc-less) candidate never replaces the running extremum. + IF value_ore IS NULL THEN + RETURN state; + END IF; + -- Adopt the candidate when the running extremum is itself non-orderable + -- (e.g. an oc-less STRICT seed) or strictly greater. + IF state_ore IS NULL OR value_ore < state_ore THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate over eql_v3.jsonb_entry. +--! @param input eql_v3.jsonb_entry +--! @return eql_v3.jsonb_entry The entry with the smallest CLLW ORE term. +CREATE AGGREGATE eql_v3.min(eql_v3.jsonb_entry) ( + sfunc = eql_v3_internal.jsonb_entry_min_sfunc, + stype = eql_v3.jsonb_entry, + combinefunc = eql_v3_internal.jsonb_entry_min_sfunc, + parallel = safe +); + +--! @brief State function for max on eql_v3.jsonb_entry. +--! +--! Keeps whichever orderable entry has the greater CLLW ORE term. `oc`-less +--! entries are skipped, mirroring `jsonb_entry_min_sfunc` (see the file @note). +--! +--! @param state eql_v3.jsonb_entry Running extremum. +--! @param value eql_v3.jsonb_entry Candidate entry. +--! @return eql_v3.jsonb_entry The greater orderable entry by `ore_cllw`. +CREATE FUNCTION eql_v3_internal.jsonb_entry_max_sfunc( + state eql_v3.jsonb_entry, + value eql_v3.jsonb_entry +) +RETURNS eql_v3.jsonb_entry +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +DECLARE + value_ore eql_v3_internal.ore_cllw := eql_v3.ore_cllw(value); + state_ore eql_v3_internal.ore_cllw := eql_v3.ore_cllw(state); +BEGIN + -- A non-orderable (oc-less) candidate never replaces the running extremum. + IF value_ore IS NULL THEN + RETURN state; + END IF; + -- Adopt the candidate when the running extremum is itself non-orderable + -- (e.g. an oc-less STRICT seed) or strictly lesser. + IF state_ore IS NULL OR value_ore > state_ore THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate over eql_v3.jsonb_entry. +--! @param input eql_v3.jsonb_entry +--! @return eql_v3.jsonb_entry The entry with the largest CLLW ORE term. +CREATE AGGREGATE eql_v3.max(eql_v3.jsonb_entry) ( + sfunc = eql_v3_internal.jsonb_entry_max_sfunc, + stype = eql_v3.jsonb_entry, + combinefunc = eql_v3_internal.jsonb_entry_max_sfunc, + parallel = safe +); +--! @file pin_search_path_v3.sql +--! @brief Post-install: pin search_path on every eql_v3.* function. +--! +--! Appended verbatim by `tasks/build.sh` to the end of the v3-only release +--! artifact, AFTER all src/v3/**/*.sql files have been concatenated. It lives +--! outside src/ so it stays out of the dependency graph. +--! +--! Iterates over functions in the `eql_v3` and `eql_v3_internal` schemas and +--! applies a fixed `search_path` via `ALTER FUNCTION ... SET search_path = ...`, +--! satisfying Supabase splinter's `function_search_path_mutable` lint. +--! +--! @note A SET clause disables SQL-function inlining. The inline-critical SEM +--! helpers (ore_block_256_*, ore_cllw_*, ore_cllw/has_ore_cllw, +--! ope_cllw, hmac_256, bloom_filter over jsonb) and the +--! encrypted-domain family (recognised structurally) are deliberately +--! left unpinned. +--! @see tasks/test/splinter.sh +--! @see tasks/build.sh + +DO $$ +DECLARE + fn_oid oid; + inline_critical_oids oid[]; + jsonb_oid oid; +BEGIN + SELECT t.oid INTO jsonb_oid + FROM pg_catalog.pg_type t + JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace + WHERE n.nspname = 'pg_catalog' AND t.typname = 'jsonb'; + + IF jsonb_oid IS NULL THEN + RAISE EXCEPTION 'pin_search_path_v3: type pg_catalog.jsonb not found'; + END IF; + + -- eql_v3 SEM index-term functions that must stay inlinable for + -- functional-index matching (no SET, IMMUTABLE). Mirrors the eql_v3 clause + -- in the legacy combined pin_search_path.sql. + SELECT pg_catalog.array_agg(p.oid) INTO inline_critical_oids + FROM pg_catalog.pg_proc p + JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace + WHERE n.nspname = ANY(eql_v3_internal.owned_schemas()) + AND ( + (p.pronargs = 2 + AND p.proname IN ('ore_block_256_eq', 'ore_block_256_neq', + 'ore_block_256_lt', 'ore_block_256_lte', + 'ore_block_256_gt', 'ore_block_256_gte')) + OR (p.pronargs = 2 + AND p.proname IN ('ore_cllw_eq', 'ore_cllw_neq', + 'ore_cllw_lt', 'ore_cllw_lte', + 'ore_cllw_gt', 'ore_cllw_gte')) + OR (p.pronargs = 1 + AND p.proname IN ('ore_cllw', 'has_ore_cllw') + AND p.proargtypes[0] = jsonb_oid) + -- The CLLW-OPE surface is the extractor alone: eql_v3_internal.ope_cllw is a + -- domain over bytea (native comparison operators and btree opclass), + -- so there are no ope-specific comparison functions to keep inlinable. + OR (p.pronargs = 1 + AND p.proname = 'ope_cllw' + AND p.proargtypes[0] = jsonb_oid) + OR (p.pronargs = 1 + AND p.proname = 'hmac_256' + AND p.proargtypes[0] = jsonb_oid) + OR (p.pronargs = 1 + AND p.proname = 'bloom_filter' + AND p.proargtypes[0] = jsonb_oid) + ); + + FOR fn_oid IN + SELECT p.oid + FROM pg_catalog.pg_proc p + JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace + WHERE n.nspname = ANY(eql_v3_internal.owned_schemas()) + AND p.prokind IN ('f', 'w') + AND NOT EXISTS ( + SELECT 1 FROM pg_catalog.unnest(coalesce(p.proconfig, '{}'::text[])) c + WHERE c LIKE 'search_path=%' + ) + AND NOT (p.oid = ANY (coalesce(inline_critical_oids, '{}'::oid[]))) + -- Encrypted-domain family — structural skip: LANGUAGE sql, IMMUTABLE, + -- taking >=1 argument typed as a jsonb-backed DOMAIN in eql_v3. + AND NOT ( + p.prolang = (SELECT l.oid FROM pg_catalog.pg_language l + WHERE l.lanname = 'sql') + AND p.provolatile = 'i' + AND EXISTS ( + SELECT 1 + FROM pg_catalog.unnest(p.proargtypes::oid[]) AS arg(typ) + JOIN pg_catalog.pg_type dt ON dt.oid = arg.typ + JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace + WHERE dt.typtype = 'd' + AND dt.typbasetype = jsonb_oid + AND dn.nspname = ANY(eql_v3_internal.owned_schemas()) + ) + ) + -- Comment-marker fallback for hand-written inline-critical extension + -- functions that take no domain argument. + AND NOT EXISTS ( + SELECT 1 FROM pg_catalog.pg_description d + WHERE d.objoid = p.oid + AND d.classoid = 'pg_catalog.pg_proc'::regclass + AND d.description LIKE 'eql-inline-critical%' + ) + LOOP + EXECUTE pg_catalog.format( + 'ALTER FUNCTION %s SET search_path = pg_catalog, extensions, public', + fn_oid::regprocedure + ); + END LOOP; +END $$; diff --git a/packages/stack/__tests__/helpers/eql-v3.ts b/packages/stack/__tests__/helpers/eql-v3.ts new file mode 100644 index 00000000..bfb8fb55 --- /dev/null +++ b/packages/stack/__tests__/helpers/eql-v3.ts @@ -0,0 +1,161 @@ +import { readFile } from 'node:fs/promises' +import { dirname, resolve } from 'node:path' +import { fileURLToPath } from 'node:url' +import type postgres from 'postgres' + +const EQL_V3_ADVISORY_LOCK_ID = 3_733_003 + +const helperDir = dirname(fileURLToPath(import.meta.url)) +// The upstream `eql-3.0.0-alpha.2` release artifact (cipherstash-encrypt.sql +// from cipherstash/encrypt-query-language), vendored byte-for-byte. +const eqlV3SqlPath = resolve( + helperDir, + '../fixtures/eql-v3/cipherstash-encrypt-v3.sql', +) +// The CLI-vendored Supabase variant (opclass chunks stripped by +// packages/cli/scripts/build-eql-v3-sql.mjs from the fixture above; CI keeps +// the two in sync). Upstream ships no Supabase variant for v3 yet, so it is +// still derived locally. Reading the shipped artifact instead of re-stripping +// here means the live Supabase suite installs exactly what +// `stash eql install --eql-version 3 --supabase` installs. +const eqlV3SupabaseSqlPath = resolve( + helperDir, + '../../../cli/src/sql/cipherstash-encrypt-v3-supabase.sql', +) + +/** + * The `eql_v3` + `eql_v3_internal` grants for the Supabase roles. Mirrors the + * CLI's `supabasePermissionsSql('eql_v3')` (packages/cli/src/installer) — + * inlined rather than imported because the stack package cannot resolve the + * cli package's dependency graph (pg) from its test context. + * + * eql_v3_internal needs the same grants: the eql_v3 operators/domain CHECKs + * call into SECURITY INVOKER functions and composite types there (SEM + * index-term internals split out in eql-3.0.0-alpha.2), so without + * USAGE/EXECUTE on eql_v3_internal every anon/authenticated encrypted query + * fails 42501. Note: Supabase "Exposed schemas" must remain eql_v3 ONLY — + * granting on eql_v3_internal does not (and must not) expose it via PostgREST. + */ +const EQL_V3_SUPABASE_GRANTS = ` + GRANT USAGE ON SCHEMA eql_v3 TO anon, authenticated, service_role; + GRANT SELECT ON ALL TABLES IN SCHEMA eql_v3 TO anon, authenticated, service_role; + GRANT EXECUTE ON ALL ROUTINES IN SCHEMA eql_v3 TO anon, authenticated, service_role; + GRANT USAGE ON ALL SEQUENCES IN SCHEMA eql_v3 TO anon, authenticated, service_role; + ALTER DEFAULT PRIVILEGES FOR ROLE postgres IN SCHEMA eql_v3 GRANT SELECT ON TABLES TO anon, authenticated, service_role; + ALTER DEFAULT PRIVILEGES FOR ROLE postgres IN SCHEMA eql_v3 GRANT EXECUTE ON ROUTINES TO anon, authenticated, service_role; + ALTER DEFAULT PRIVILEGES FOR ROLE postgres IN SCHEMA eql_v3 GRANT USAGE ON SEQUENCES TO anon, authenticated, service_role; + GRANT USAGE ON SCHEMA eql_v3_internal TO anon, authenticated, service_role; + GRANT SELECT ON ALL TABLES IN SCHEMA eql_v3_internal TO anon, authenticated, service_role; + GRANT EXECUTE ON ALL ROUTINES IN SCHEMA eql_v3_internal TO anon, authenticated, service_role; + GRANT USAGE ON ALL SEQUENCES IN SCHEMA eql_v3_internal TO anon, authenticated, service_role; + ALTER DEFAULT PRIVILEGES FOR ROLE postgres IN SCHEMA eql_v3_internal GRANT SELECT ON TABLES TO anon, authenticated, service_role; + ALTER DEFAULT PRIVILEGES FOR ROLE postgres IN SCHEMA eql_v3_internal GRANT EXECUTE ON ROUTINES TO anon, authenticated, service_role; + ALTER DEFAULT PRIVILEGES FOR ROLE postgres IN SCHEMA eql_v3_internal GRANT USAGE ON SEQUENCES TO anon, authenticated, service_role; +` + +/** + * Generation-aware install sentinel. `to_regtype('eql_v3.text_search')` alone + * is NOT enough: text_search exists in both the pre-alpha.2 snapshot and the + * current bundle, so a stale old-generation install would be silently reused. + * The eql_v3_internal schema and the SQL-standard-renamed eql_v3.timestamp + * domain only exist in the eql-3.0.0-alpha.2 generation, so requiring them + * distinguishes current from stale. + */ +async function hasCurrentGenerationEqlV3(sql: postgres.Sql): Promise<boolean> { + const [row] = await sql<{ installed: boolean }[]>` + SELECT + to_regtype('eql_v3.text_search') IS NOT NULL + AND to_regtype('eql_v3.timestamp') IS NOT NULL + AND EXISTS ( + SELECT 1 FROM pg_namespace WHERE nspname = 'eql_v3_internal' + ) AS installed + ` + return row?.installed ?? false +} + +/** + * Install the vendored EQL v3 SQL bundle (eql-3.0.0-alpha.2) only when the + * target database does not already have a current-generation install. + * + * The bundle starts with DROP SCHEMA IF EXISTS eql_v3 CASCADE (and drops + * eql_v3_internal too), so callers must never run it unconditionally against + * a shared test database. + * + * Pass `supabase: true` when targeting a Supabase database: the operator + * class/family chunks are stripped (they need superuser) and the `eql_v3` and + * `eql_v3_internal` schemas are granted to the Supabase roles, mirroring the + * CLI's `--eql-version 3 --supabase` install. + */ +export async function installEqlV3IfNeeded( + sql: postgres.Sql, + options?: { supabase?: boolean }, +): Promise<void> { + // Advisory locks are session-scoped, so the whole check/install/unlock flow + // must run on a single reserved connection. Issuing the lock/unlock via the + // pool can land them on different pooled backends — allowing an install race + // and unlocking a backend that never held the lock. + const reserved = await sql.reserve() + + try { + await reserved`SELECT pg_advisory_lock(${EQL_V3_ADVISORY_LOCK_ID})` + + try { + if (await hasCurrentGenerationEqlV3(reserved)) return + + // Reaching here means either nothing is installed, or a STALE + // previous-generation install is present (eql_v3 exists — e.g. + // eql_v3.text_search resolves — but the eql_v3_internal schema / + // renamed domains are absent). Either way, re-run the bundle: it opens + // with DROP SCHEMA IF EXISTS eql_v3 CASCADE and DROP SCHEMA IF EXISTS + // eql_v3_internal CASCADE, so the stale install is replaced wholesale. + // Belt-and-braces: drop eql_v3_internal explicitly first so the + // reinstall stays idempotent even if a future bundle stops dropping it. + await reserved`DROP SCHEMA IF EXISTS eql_v3_internal CASCADE` + + const eqlV3Sql = await readFile( + options?.supabase ? eqlV3SupabaseSqlPath : eqlV3SqlPath, + 'utf8', + ) + await reserved.unsafe(eqlV3Sql) + + if (options?.supabase) { + // The Supabase roles don't own the schemas; without these grants every + // encrypted query fails 42501 over PostgREST. + await reserved.unsafe(EQL_V3_SUPABASE_GRANTS) + } + + if (!(await hasCurrentGenerationEqlV3(reserved))) { + throw new Error( + 'EQL v3 installation did not create the current-generation eql_v3 surface (eql_v3.text_search, eql_v3.timestamp, eql_v3_internal)', + ) + } + } finally { + await reserved`SELECT pg_advisory_unlock(${EQL_V3_ADVISORY_LOCK_ID})` + } + } finally { + reserved.release() + } +} + +/** + * Version-handshake guard for the live suites: assert that a payload the + * client just produced is a v:3-wire envelope matching the installed bundle's + * domain CHECK pins (`VALUE->>'v' = '3'`, eql-3.0.0-alpha.2). A mismatch means + * generation skew — a stale protect-ffi pin, missing `eqlVersion: 3` wiring, + * or a stale vendored bundle — exactly the drift class that previously went + * unnoticed (PR #547 originally wrote v2-wire data against v:2 CHECK pins). + * Fail loudly and name the skew instead of letting inserts fail with an + * opaque 23514 (or, worse, a mismatched bundle silently accept them). + */ +export function assertV3WireEnvelope(payload: unknown, context: string): void { + const v = + typeof payload === 'object' && payload !== null + ? (payload as Record<string, unknown>).v + : undefined + if (v !== 3) { + throw new Error( + `EQL generation skew (${context}): client emitted an envelope with v=${JSON.stringify(v)} but the installed eql_v3 bundle (eql-3.0.0-alpha.2) pins v='3'. ` + + 'Check the @cipherstash/protect-ffi version (needs >= 0.27.0), the eqlVersion wiring (EncryptionV3 / Encryption auto-detection), and the vendored bundle generation.', + ) + } +} diff --git a/packages/stack/__tests__/helpers/live-gate.ts b/packages/stack/__tests__/helpers/live-gate.ts new file mode 100644 index 00000000..8ad3675e --- /dev/null +++ b/packages/stack/__tests__/helpers/live-gate.ts @@ -0,0 +1,28 @@ +import { describe } from 'vitest' + +/** + * Shared env gates for the live (network-touching) suites. Previously each + * live suite re-declared these; one definition keeps the credential list — + * and therefore what "live" means — from drifting between files. + * + * Callers must `import 'dotenv/config'` BEFORE importing this module (all + * live suites already do, as their first import) so the env is populated + * when these are evaluated. + */ + +/** True when live CipherStash (ZeroKMS/CTS) credentials are configured. */ +export const LIVE_CIPHERSTASH_ENABLED = Boolean( + process.env.CS_WORKSPACE_CRN && + process.env.CS_CLIENT_ID && + process.env.CS_CLIENT_KEY && + process.env.CS_CLIENT_ACCESS_KEY, +) + +/** True when live credentials AND a Postgres `DATABASE_URL` are configured. */ +export const LIVE_EQL_V3_PG_ENABLED = Boolean( + process.env.DATABASE_URL && LIVE_CIPHERSTASH_ENABLED, +) + +export const describeLive = LIVE_CIPHERSTASH_ENABLED ? describe : describe.skip + +export const describeLivePg = LIVE_EQL_V3_PG_ENABLED ? describe : describe.skip diff --git a/packages/stack/__tests__/helpers/stub-auth-wasm-inline.ts b/packages/stack/__tests__/helpers/stub-auth-wasm-inline.ts new file mode 100644 index 00000000..23711105 --- /dev/null +++ b/packages/stack/__tests__/helpers/stub-auth-wasm-inline.ts @@ -0,0 +1,23 @@ +/** + * Test stub for `@cipherstash/auth/wasm-inline`. + * + * See {@link file://./stub-protect-ffi-wasm-inline.ts} — the `/wasm-inline` + * subpath is not exported by the installed `@cipherstash/auth`, so this stub + * lets Vitest load `src/wasm-inline` for pure-helper unit tests. Aliased in via + * `vitest.config.ts`. + */ +export const AccessKeyStrategy = { + create: (): never => { + throw new Error( + '[test stub]: auth/wasm-inline AccessKeyStrategy.create not implemented', + ) + }, +} + +export const OidcFederationStrategy = { + create: (): never => { + throw new Error( + '[test stub]: auth/wasm-inline OidcFederationStrategy.create not implemented', + ) + }, +} diff --git a/packages/stack/__tests__/helpers/stub-protect-ffi-wasm-inline.ts b/packages/stack/__tests__/helpers/stub-protect-ffi-wasm-inline.ts new file mode 100644 index 00000000..e26d34df --- /dev/null +++ b/packages/stack/__tests__/helpers/stub-protect-ffi-wasm-inline.ts @@ -0,0 +1,29 @@ +/** + * Test stub for `@cipherstash/protect-ffi/wasm-inline`. + * + * The installed `@cipherstash/protect-ffi` only exports `.` — the `/wasm-inline` + * subpath does not exist, so Vitest cannot resolve `src/wasm-inline` (which + * imports it). These no-op stubs let the unit tests that only exercise pure + * helpers (`getColumnName`, `normalizeCastAs`) load the module. Aliased in via + * `vitest.config.ts`. Any test that actually needs WASM behaviour must mock it + * explicitly (see `wasm-inline-column-name.test.ts`). + */ +export const decrypt = (): never => { + throw new Error( + '[test stub]: protect-ffi/wasm-inline decrypt not implemented', + ) +} + +export const encrypt = (): never => { + throw new Error( + '[test stub]: protect-ffi/wasm-inline encrypt not implemented', + ) +} + +export const isEncrypted = (): boolean => false + +export const newClient = (): never => { + throw new Error( + '[test stub]: protect-ffi/wasm-inline newClient not implemented', + ) +} diff --git a/packages/stack/__tests__/init-strategy.test.ts b/packages/stack/__tests__/init-strategy.test.ts index b73979ea..7d729e6f 100644 --- a/packages/stack/__tests__/init-strategy.test.ts +++ b/packages/stack/__tests__/init-strategy.test.ts @@ -11,9 +11,10 @@ */ import { beforeEach, describe, expect, it, vi } from 'vitest' +import { EncryptionV3 } from '@/encryption/v3' import { Encryption } from '@/index' import { encryptedColumn, encryptedTable } from '@/schema' -import type { AuthStrategy } from '@/types' +import type { AuthStrategy, BuildableTable } from '@/types' vi.mock('@cipherstash/protect-ffi', () => ({ newClient: vi.fn(async () => ({ __mock: 'client' })), @@ -97,3 +98,76 @@ describe('Encryption config.strategy', () => { expect(opts.strategy).toBeUndefined() }) }) + +// A minimal structural EQL v3 table: what marks a table as v3 for wire-format +// detection is its `buildColumnKeyMap()` method (v2 tables have none). Built +// by hand rather than via `@cipherstash/stack/v3` so this suite pins the +// structural contract `Encryption` actually dispatches on. +const v3Table = (tableName = 'v3_users'): BuildableTable => + ({ + tableName, + build: () => ({ + tableName, + columns: { email: { cast_as: 'text', indexes: { unique: {} } } }, + }), + buildColumnKeyMap: () => ({ email: 'email' }), + }) as BuildableTable + +describe('Encryption config.eqlVersion', () => { + // biome-ignore lint/suspicious/noExplicitAny: reading recorded mock args + const lastNewClientOpts = () => + vi.mocked(ffi.newClient).mock.calls.at(-1)![0] as any + + it('leaves eqlVersion undefined for a v2 schema set (FFI default, byte-identical v2 wire)', async () => { + await Encryption({ schemas: [users] }) + + expect(lastNewClientOpts().eqlVersion).toBeUndefined() + }) + + it('auto-detects eqlVersion 3 when every schema is a v3 table', async () => { + await Encryption({ schemas: [v3Table()] }) + + expect(lastNewClientOpts().eqlVersion).toBe(3) + }) + + it('forwards an explicit eqlVersion for a v2 schema set', async () => { + await Encryption({ schemas: [users], config: { eqlVersion: 3 } }) + + expect(lastNewClientOpts().eqlVersion).toBe(3) + }) + + it('lets an explicit eqlVersion 2 override v3 auto-detection (migration escape hatch)', async () => { + await Encryption({ schemas: [v3Table()], config: { eqlVersion: 2 } }) + + expect(lastNewClientOpts().eqlVersion).toBe(2) + }) + + it('throws on a mixed v2 + v3 schema set — one client emits one wire format', async () => { + await expect(Encryption({ schemas: [users, v3Table()] })).rejects.toThrow( + /cannot mix EQL v2 and EQL v3 tables/, + ) + }) + + it('throws on a mixed schema set even with an explicit eqlVersion', async () => { + await expect( + Encryption({ schemas: [users, v3Table()], config: { eqlVersion: 3 } }), + ).rejects.toThrow(/cannot mix EQL v2 and EQL v3 tables/) + }) + + it('EncryptionV3 creates the underlying client with eqlVersion 3', async () => { + // The duck-typed table satisfies the runtime contract; the type-level + // AnyV3Table constraint is beside the point for this wiring assertion. + await EncryptionV3({ schemas: [v3Table() as never] }) + + expect(lastNewClientOpts().eqlVersion).toBe(3) + }) + + it('EncryptionV3 honours an explicit eqlVersion override', async () => { + await EncryptionV3({ + schemas: [v3Table() as never], + config: { eqlVersion: 2 }, + }) + + expect(lastNewClientOpts().eqlVersion).toBe(2) + }) +}) diff --git a/packages/stack/__tests__/model-column-mapping.test.ts b/packages/stack/__tests__/model-column-mapping.test.ts new file mode 100644 index 00000000..55c19002 --- /dev/null +++ b/packages/stack/__tests__/model-column-mapping.test.ts @@ -0,0 +1,39 @@ +import { describe, expect, it } from 'vitest' +import { resolveEncryptColumnMap } from '@/encryption/helpers/model-helpers' +import { encryptedTable, types } from '@/eql/v3' +import { encryptedColumn, encryptedTable as encryptedTableV2 } from '@/schema' + +// `resolveEncryptColumnMap` is how the model path reconciles the two keyings a +// table can use: models are matched by JS property name, but the FFI / encrypt +// config is addressed by DB column name. A mismatch here is a real data-leak +// bug — a schema field that fails to match is passed through as plaintext. +describe('resolveEncryptColumnMap', () => { + it('v3: matches by JS property, addresses the FFI by DB name', () => { + const users = encryptedTable('users', { + createdOn: types.Date('created_on'), + notes: types.Text('notes'), // property == name + }) + + const { columnPaths, toColumnName } = resolveEncryptColumnMap(users) + + // Fields are matched against JS property names (what a model is keyed by)… + expect(columnPaths.sort()).toEqual(['createdOn', 'notes']) + // …and each maps to the DB name the config/FFI is keyed by. + expect(toColumnName('createdOn')).toBe('created_on') + expect(toColumnName('notes')).toBe('notes') + }) + + it('v2: no property→DB map, so both keying schemes are the JS property', () => { + // v2 `build()` keys columns by the JS property, so matching and addressing + // use that same key — the resolver must fall back to identity and leave the + // v2 model path unchanged. + const legacy = encryptedTableV2('legacy', { + fooBar: encryptedColumn('foo_bar'), + }) + + const { columnPaths, toColumnName } = resolveEncryptColumnMap(legacy) + + expect(columnPaths).toEqual(['fooBar']) + expect(toColumnName('fooBar')).toBe('fooBar') + }) +}) diff --git a/packages/stack/__tests__/schema-v3-client.test.ts b/packages/stack/__tests__/schema-v3-client.test.ts new file mode 100644 index 00000000..b4838abd --- /dev/null +++ b/packages/stack/__tests__/schema-v3-client.test.ts @@ -0,0 +1,275 @@ +import 'dotenv/config' +import { beforeAll, describe, expect, it } from 'vitest' +import type { EncryptionClient } from '@/encryption' +import { typedClient } from '@/encryption/v3' +import { encryptedTable, types } from '@/eql/v3' +import { Encryption } from '@/index' +import { unwrapResult } from './fixtures' +import { describeLive, LIVE_CIPHERSTASH_ENABLED } from './helpers/live-gate' + +const users = encryptedTable('schema_v3_client_users', { + email: types.TextSearch('email'), + age: types.IntegerOrd('age'), + nickname: types.TextEq('nickname'), + body: types.TextMatch('body'), + notes: types.Text('notes'), + active: types.Boolean('active'), + // camelCase JS property → snake_case DB name on purpose: the model path must + // match models by JS property (`createdOn`) yet address the FFI/config by DB + // name (`created_on`). The round-trip tests below exercise that mapping. + createdOn: types.Date('created_on'), + occurredAt: types.Timestamp('occurred_at'), +}) + +describeLive('eql_v3 client integration', () => { + let protectClient: EncryptionClient + // INTERIM (CIP-3402): protect-ffi 0.27 has no v3 scalar query wire shape — + // scalar encryptQuery on the v3-wire client throws EQL_V3_QUERY_UNSUPPORTED. + // Query-term shape assertions run against a second, explicitly v2-wire client + // over the same schemas (index terms are identical across wire formats). + let termClient: EncryptionClient + + beforeAll(async () => { + protectClient = await Encryption({ schemas: [users] }) + termClient = await Encryption({ + schemas: [users], + config: { eqlVersion: 2 }, + }) + }) + + it('encrypts and decrypts a text_search column', async () => { + const encrypted = unwrapResult( + await protectClient.encrypt('ada@example.com', { + table: users, + column: users.email, + }), + ) + + expect(encrypted).toMatchObject({ + i: { t: 'schema_v3_client_users', c: 'email' }, + // v3-wire storage envelope (eqlVersion: 3 client over v3 schemas) + v: 3, + }) + expect(encrypted).toHaveProperty('c') + expect(encrypted).toHaveProperty('hm') + expect(encrypted).toHaveProperty('bf') + expect(encrypted).toHaveProperty('ob') + + const decrypted = unwrapResult(await protectClient.decrypt(encrypted)) + expect(decrypted).toBe('ada@example.com') + }, 30000) + + it('auto-infers equality query terms for text_search columns', async () => { + const queryTerm = unwrapResult( + await termClient.encryptQuery('ada@example.com', { + table: users, + column: users.email, + }), + ) + + expect(queryTerm).toMatchObject({ + i: { t: 'schema_v3_client_users', c: 'email' }, + // v2-wire: terms come from the interim v2 term client (CIP-3402) + v: 2, + }) + expect(queryTerm).toHaveProperty('hm') + expect(queryTerm).not.toHaveProperty('c') + }, 30000) + + it('rejects scalar encryptQuery on the v3-wire client (no v3 scalar query wire shape yet)', async () => { + // Pins the FFI behaviour the Supabase adapter's interim full-envelope + // operand path depends on: under eqlVersion 3, scalar index queries + // throw EQL_V3_QUERY_UNSUPPORTED until an EQL scalar query envelope + // exists (CIP-3402). + const result = await protectClient.encryptQuery('ada@example.com', { + table: users, + column: users.email, + }) + expect(result.failure).toBeDefined() + expect(result.failure?.message).toMatch(/unsupported|eqlVersion/i) + }, 30000) + + it('encrypts explicit freeTextSearch and orderAndRange query terms', async () => { + const matchTerm = unwrapResult( + await termClient.encryptQuery('Ada Lovelace', { + table: users, + column: users.email, + queryType: 'freeTextSearch', + }), + ) + + const orderTerm = unwrapResult( + await termClient.encryptQuery('ada@example.com', { + table: users, + column: users.email, + queryType: 'orderAndRange', + }), + ) + + expect(matchTerm).toHaveProperty('bf') + expect(matchTerm).not.toHaveProperty('c') + expect(orderTerm).toHaveProperty('ob') + expect(orderTerm).not.toHaveProperty('c') + }, 30000) + + it('encrypts and decrypts storage-only v3 columns', async () => { + const encryptedText = unwrapResult( + await protectClient.encrypt('private note', { + table: users, + column: users.notes, + }), + ) + expect(encryptedText).toMatchObject({ + i: { t: 'schema_v3_client_users', c: 'notes' }, + v: 3, + }) + expect(encryptedText).toHaveProperty('c') + expect(encryptedText).not.toHaveProperty('hm') + expect(encryptedText).not.toHaveProperty('bf') + expect(encryptedText).not.toHaveProperty('ob') + expect(unwrapResult(await protectClient.decrypt(encryptedText))).toBe( + 'private note', + ) + + const encryptedBool = unwrapResult( + await protectClient.encrypt(true, { + table: users, + column: users.active, + }), + ) + expect(encryptedBool).toHaveProperty('c') + expect(unwrapResult(await protectClient.decrypt(encryptedBool))).toBe(true) + }, 30000) + + it('encrypts equality and order query terms for typed v3 columns', async () => { + const equalityTerm = unwrapResult( + await termClient.encryptQuery('ada', { + table: users, + column: users.nickname, + }), + ) + expect(equalityTerm).toHaveProperty('hm') + expect(equalityTerm).not.toHaveProperty('c') + + const orderTerm = unwrapResult( + await termClient.encryptQuery(37, { + table: users, + column: users.age, + queryType: 'orderAndRange', + }), + ) + expect(orderTerm).toHaveProperty('ob') + expect(orderTerm).not.toHaveProperty('c') + }, 30000) + + it('encrypts free-text terms for text_match columns', async () => { + const encrypted = unwrapResult( + await protectClient.encrypt('Ada Lovelace wrote notes', { + table: users, + column: users.body, + }), + ) + expect(encrypted).toHaveProperty('c') + expect(encrypted).toHaveProperty('bf') + expect(encrypted).not.toHaveProperty('hm') + expect(encrypted).not.toHaveProperty('ob') + + const matchTerm = unwrapResult( + await termClient.encryptQuery('Lovelace', { + table: users, + column: users.body, + queryType: 'freeTextSearch', + }), + ) + expect(matchTerm).toHaveProperty('bf') + expect(matchTerm).not.toHaveProperty('c') + }, 30000) + + // bigint (int8) storage domains are omitted from the v3 SDK until the native + // protect-ffi supports lossless bigint round-tripping — a `bigint` fails JSON + // serialization and a `string` is rejected for a `big_int` column. Re-add a + // round-trip test alongside the domain builders when the FFI lands. + + // A `date` domain decrypts to an ISO 8601 string from the native FFI, so the + // single-value `decrypt` path returns a string (a lone ciphertext carries no + // column context). The typed client's `decryptModel` reconstructs a real + // `Date` from the encrypt-config `cast_as` (`reconstructRow`), keyed by the + // JS property (`createdOn`) even though the DB column is `created_on`. + it('round-trips a representative date storage domain via decryptModel', async () => { + const typed = typedClient(protectClient, users) + // Zero milliseconds so the FFI dropping sub-second precision (`...00Z` vs + // `...000Z`) does not perturb the reconstructed instant. + const day = new Date('2026-07-01T00:00:00.000Z') + + // Encrypt via the single-value path (the proven route for a `Date` domain), + // then decrypt through the model path so `reconstructRow` rebuilds a `Date` + // from the encrypt-config `cast_as`. + const dateEncrypted = unwrapResult( + await protectClient.encrypt(day, { + table: users, + column: users.createdOn, + }), + ) + // Guard against a false pass: the value must be an actual ciphertext, not a + // plaintext `Date` that would trivially satisfy the assertions below. + expect(dateEncrypted).toHaveProperty('c') + + const decrypted = unwrapResult( + await typed.decryptModel({ createdOn: dateEncrypted }, users), + ) + expect(decrypted.createdOn).toBeInstanceOf(Date) + expect(decrypted.createdOn).toEqual(day) + }, 30000) + + // Regression: a camelCase JS property mapping to a snake_case DB column + // (`nickname` is name==key, but `createdOn`→`created_on` is not) must be + // ENCRYPTED by the model path — not silently passed through as plaintext + // because the field key (`createdOn`) fails to match the DB-keyed config. + it('encrypts a property-vs-DB-name column through encryptModel (no plaintext leak)', async () => { + const typed = typedClient(protectClient, users) + const day = new Date('2026-07-01T00:00:00.000Z') + + const encrypted = unwrapResult( + await typed.encryptModel({ createdOn: day, notes: 'hello' }, users), + ) + // The schema field must become a ciphertext (has `c`), NOT remain a Date. + expect(encrypted.createdOn).not.toBeInstanceOf(Date) + expect(encrypted.createdOn).toHaveProperty('c') + expect(encrypted.notes).toHaveProperty('c') + + const decrypted = unwrapResult(await typed.decryptModel(encrypted, users)) + expect(decrypted.createdOn).toBeInstanceOf(Date) + expect(decrypted.createdOn).toEqual(day) + expect(decrypted.notes).toBe('hello') + }, 30000) + + // Hygiene: `occurredAt` (a timestamp column, camelCase property → + // snake_case DB name `occurred_at`) was declared in the test table but never + // asserted. Give it a real round-trip through the model path, complementing + // the `createdOn` date case above. (`matrix-live.test.ts` is the canonical + // generic coverage for all timestamp tiers; this pins the named column.) + // + // Previously SKIPPED (CI run 28569708268, PR #540): decrypted `occurredAt` + // came back at midnight (`00:00:00.000Z`), losing the time-of-day, because + // every timestamp domain set `cast_as: 'date'` and the native layer + // truncates 'date' values to the calendar date. Re-enabled now that the + // timestamp domains emit the FFI's distinct `cast_as: 'timestamp'` + // (full date+time) variant. + it('round-trips a timestamp occurredAt column through the model path', async () => { + const typed = typedClient(protectClient, users) + // Zero milliseconds: the FFI drops sub-second precision, so a ms-bearing + // instant would perturb the reconstructed value. + const moment = new Date('2026-07-01T12:34:56.000Z') + + const encrypted = unwrapResult( + await typed.encryptModel({ occurredAt: moment, notes: 'seen' }, users), + ) + // Must become a ciphertext, not remain a Date (no plaintext passthrough). + expect(encrypted.occurredAt).not.toBeInstanceOf(Date) + expect(encrypted.occurredAt).toHaveProperty('c') + + const decrypted = unwrapResult(await typed.decryptModel(encrypted, users)) + expect(decrypted.occurredAt).toBeInstanceOf(Date) + expect(decrypted.occurredAt).toEqual(moment) + }, 30000) +}) diff --git a/packages/stack/__tests__/schema-v3-pg.test.ts b/packages/stack/__tests__/schema-v3-pg.test.ts new file mode 100644 index 00000000..a971cae9 --- /dev/null +++ b/packages/stack/__tests__/schema-v3-pg.test.ts @@ -0,0 +1,405 @@ +import 'dotenv/config' +import postgres from 'postgres' +import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest' +import type { EncryptionClient } from '@/encryption' +import { encryptedTable, types } from '@/eql/v3' +import { Encryption } from '@/index' +import type { Encrypted } from '@/types' +import { unwrapResult } from './fixtures' +import { assertV3WireEnvelope, installEqlV3IfNeeded } from './helpers/eql-v3' +import { describeLivePg, LIVE_EQL_V3_PG_ENABLED } from './helpers/live-gate' + +const databaseUrl = process.env.DATABASE_URL +const sql = LIVE_EQL_V3_PG_ENABLED + ? postgres(databaseUrl as string, { prepare: false }) + : (undefined as unknown as postgres.Sql) + +const table = encryptedTable('protect_ci_v3_text_search', { + email: types.TextSearch('email'), +}) + +const typedTable = encryptedTable('protect_ci_v3_typed_domains', { + age: types.IntegerOrd('age'), + nickname: types.TextEq('nickname'), + active: types.Boolean('active'), +}) + +const TEST_RUN_ID = `test-run-${Date.now()}-${Math.random().toString(36).slice(2, 8)}` + +type InsertedRow = { + id: number + email: unknown + label: string +} + +type EncryptionPayload = postgres.JSONValue + +let protectClient: EncryptionClient +// INTERIM (CIP-3402): protect-ffi 0.27 has no v3 scalar query wire shape — +// scalar encryptQuery on a v3-wire client throws EQL_V3_QUERY_UNSUPPORTED. +// Query terms are built with a second, explicitly v2-wire client over the +// same schemas; the eql_v3_internal extractors these tests feed terms to +// (hmac_256 / bloom_filter / ore_block_256) read only the term keys from the +// jsonb, and index terms are identical across wire formats. +let termClient: EncryptionClient + +async function encryptValue(value: string): Promise<EncryptionPayload> { + const payload = unwrapResult( + await protectClient.encrypt(value, { + table, + column: table.email, + }), + ) as EncryptionPayload + // Generation handshake: fail loudly on client/bundle wire-format skew. + assertV3WireEnvelope(payload, 'schema-v3-pg encryptValue') + return payload +} + +async function encryptQueryTerm( + value: string, + queryType?: 'equality' | 'freeTextSearch' | 'orderAndRange', +): Promise<EncryptionPayload> { + return unwrapResult( + await termClient.encryptQuery(value, { + table, + column: table.email, + queryType, + }), + ) as EncryptionPayload +} + +async function insertRow(label: string, email: string): Promise<number> { + const encrypted = await encryptValue(email) + + const [inserted] = await sql<{ id: number }[]>` + INSERT INTO protect_ci_v3_text_search (email, label, test_run_id) + VALUES (${sql.json(encrypted)}::eql_v3.text_search, ${label}, ${TEST_RUN_ID}) + RETURNING id + ` + + return inserted.id +} + +async function decryptRow(row: InsertedRow): Promise<string> { + const decrypted = unwrapResult( + await protectClient.decrypt(row.email as Encrypted), + ) + expect(typeof decrypted).toBe('string') + return decrypted as string +} + +async function seedRows(): Promise<Record<string, number>> { + const rows = { + ada: await insertRow('ada', 'ada@example.com'), + grace: await insertRow('grace', 'grace@example.com'), + alan: await insertRow('alan', 'alan@example.net'), + zora: await insertRow('zora', 'zora@example.org'), + } + + return rows +} + +beforeAll(async () => { + if (!LIVE_EQL_V3_PG_ENABLED) return + + await installEqlV3IfNeeded(sql) + protectClient = await Encryption({ schemas: [table, typedTable] }) + // v2-wire term client (see the INTERIM note above the declarations). + termClient = await Encryption({ + schemas: [table, typedTable], + config: { eqlVersion: 2 }, + }) + + await sql` + CREATE TABLE IF NOT EXISTS protect_ci_v3_text_search ( + id INTEGER PRIMARY KEY GENERATED ALWAYS AS IDENTITY, + email eql_v3.text_search NOT NULL, + label TEXT NOT NULL, + test_run_id TEXT NOT NULL + ) + ` + + await sql` + CREATE TABLE IF NOT EXISTS protect_ci_v3_typed_domains ( + id INTEGER PRIMARY KEY GENERATED ALWAYS AS IDENTITY, + age eql_v3.integer_ord NOT NULL, + nickname eql_v3.text_eq NOT NULL, + active eql_v3.boolean NOT NULL, + test_run_id TEXT NOT NULL + ) + ` +}, 30000) + +beforeEach(async () => { + if (!LIVE_EQL_V3_PG_ENABLED) return + + await sql` + DELETE FROM protect_ci_v3_text_search + WHERE test_run_id = ${TEST_RUN_ID} + ` + await sql` + DELETE FROM protect_ci_v3_typed_domains + WHERE test_run_id = ${TEST_RUN_ID} + ` +}, 30000) + +afterAll(async () => { + if (!LIVE_EQL_V3_PG_ENABLED) return + + await sql` + DELETE FROM protect_ci_v3_text_search + WHERE test_run_id = ${TEST_RUN_ID} + ` + await sql` + DELETE FROM protect_ci_v3_typed_domains + WHERE test_run_id = ${TEST_RUN_ID} + ` + await sql.end() +}, 30000) + +describeLivePg('eql_v3 text_search postgres integration', () => { + it('round-trips an encrypted value through an eql_v3.text_search column', async () => { + const id = await insertRow('roundtrip', 'roundtrip@example.com') + + const [row] = await sql<InsertedRow[]>` + SELECT id, email::jsonb AS email, label + FROM protect_ci_v3_text_search + WHERE id = ${id} + ` + + expect(row).toBeDefined() + await expect(decryptRow(row)).resolves.toBe('roundtrip@example.com') + }, 30000) + + it('queries equality terms with eql_v3.eq_term and eql_v3_internal.hmac_256', async () => { + const ids = await seedRows() + const equalityTerm = await encryptQueryTerm('grace@example.com', 'equality') + + const rows = await sql<InsertedRow[]>` + SELECT id, email::jsonb AS email, label + FROM protect_ci_v3_text_search + WHERE test_run_id = ${TEST_RUN_ID} + AND eql_v3.eq_term(email) = eql_v3_internal.hmac_256(${sql.json(equalityTerm)}::jsonb) + ORDER BY id + ` + + expect(rows.map((row) => row.id)).toEqual([ids.grace]) + await expect(decryptRow(rows[0])).resolves.toBe('grace@example.com') + }, 30000) + + it('queries free-text terms with eql_v3.match_term and eql_v3_internal.bloom_filter', async () => { + await seedRows() + const matchTerm = await encryptQueryTerm('example.com', 'freeTextSearch') + + const rows = await sql<InsertedRow[]>` + SELECT id, email::jsonb AS email, label + FROM protect_ci_v3_text_search + WHERE test_run_id = ${TEST_RUN_ID} + AND eql_v3.match_term(email) @> eql_v3_internal.bloom_filter(${sql.json(matchTerm)}::jsonb) + ORDER BY label + ` + + expect(rows.map((row) => row.label)).toEqual(['ada', 'grace']) + }, 30000) + + it('queries range terms with eql_v3.ord_term and eql_v3_internal.ore_block_256', async () => { + await seedRows() + const lower = await encryptQueryTerm('grace@example.com', 'orderAndRange') + const upper = await encryptQueryTerm('zora@example.org', 'orderAndRange') + + const rows = await sql<InsertedRow[]>` + SELECT id, email::jsonb AS email, label + FROM protect_ci_v3_text_search + WHERE test_run_id = ${TEST_RUN_ID} + AND eql_v3.ord_term(email) >= eql_v3_internal.ore_block_256(${sql.json(lower)}::jsonb) + AND eql_v3.ord_term(email) <= eql_v3_internal.ore_block_256(${sql.json(upper)}::jsonb) + ORDER BY eql_v3.ord_term(email) + ` + + expect(rows.map((row) => row.label)).toEqual(['grace', 'zora']) + }, 30000) + + it('creates functional indexes for equality, match, and order terms', async () => { + await sql` + CREATE INDEX IF NOT EXISTS protect_ci_v3_text_search_email_eq_idx + ON protect_ci_v3_text_search USING btree (eql_v3.eq_term(email)) + ` + await sql` + CREATE INDEX IF NOT EXISTS protect_ci_v3_text_search_email_match_idx + ON protect_ci_v3_text_search USING gin (eql_v3.match_term(email)) + ` + await sql` + CREATE INDEX IF NOT EXISTS protect_ci_v3_text_search_email_ord_idx + ON protect_ci_v3_text_search USING btree (eql_v3.ord_term(email)) + ` + + const indexes = await sql<{ indexname: string; indexdef: string }[]>` + SELECT indexname, indexdef + FROM pg_indexes + WHERE schemaname = 'public' + AND tablename = 'protect_ci_v3_text_search' + AND indexname IN ( + 'protect_ci_v3_text_search_email_eq_idx', + 'protect_ci_v3_text_search_email_match_idx', + 'protect_ci_v3_text_search_email_ord_idx' + ) + ` + + expect(indexes).toHaveLength(3) + expect(indexes.map((idx) => idx.indexdef).join('\n')).toContain( + 'eql_v3.eq_term', + ) + expect(indexes.map((idx) => idx.indexdef).join('\n')).toContain( + 'eql_v3.match_term', + ) + expect(indexes.map((idx) => idx.indexdef).join('\n')).toContain( + 'eql_v3.ord_term', + ) + }, 30000) + + it('rejects query-only payloads cast as eql_v3.text_search values', async () => { + const equalityTerm = await encryptQueryTerm('ada@example.com', 'equality') + + await expect( + sql` + INSERT INTO protect_ci_v3_text_search (email, label, test_run_id) + VALUES ( + ${sql.json(equalityTerm)}::eql_v3.text_search, + 'query-only', + ${TEST_RUN_ID} + ) + `, + ).rejects.toThrow() + }, 30000) + + it('round-trips and queries representative typed v3 domains', async () => { + const age = unwrapResult( + await protectClient.encrypt(37, { + table: typedTable, + column: typedTable.age, + }), + ) + const nickname = unwrapResult( + await protectClient.encrypt('ada', { + table: typedTable, + column: typedTable.nickname, + }), + ) + const active = unwrapResult( + await protectClient.encrypt(true, { + table: typedTable, + column: typedTable.active, + }), + ) + + const [inserted] = await sql<{ id: number }[]>` + INSERT INTO protect_ci_v3_typed_domains (age, nickname, active, test_run_id) + VALUES ( + ${sql.json(age as postgres.JSONValue)}::eql_v3.integer_ord, + ${sql.json(nickname as postgres.JSONValue)}::eql_v3.text_eq, + ${sql.json(active as postgres.JSONValue)}::eql_v3.boolean, + ${TEST_RUN_ID} + ) + RETURNING id + ` + + const ageTerm = unwrapResult( + await termClient.encryptQuery(30, { + table: typedTable, + column: typedTable.age, + queryType: 'orderAndRange', + }), + ) as postgres.JSONValue + + const rows = await sql<{ id: number }[]>` + SELECT id + FROM protect_ci_v3_typed_domains + WHERE test_run_id = ${TEST_RUN_ID} + AND eql_v3.ord_term(age) >= eql_v3_internal.ore_block_256(${sql.json(ageTerm)}::jsonb) + ` + + expect(rows.map((row) => row.id)).toContain(inserted.id) + }, 30000) + + // Correctness proof for the equality-via-ORE fix (Part A). The deterministic + // regression proves `resolveIndexType` resolves equality to `ore` instead of + // throwing; this proves the resulting term actually SELECTS the right rows + // against real Postgres, using the SQL `=` operator on the ORE term. + it('selects the exact row for an equality term via ORE on an integer_ord column', async () => { + async function insertAge(age: number): Promise<number> { + const ageCt = unwrapResult( + await protectClient.encrypt(age, { + table: typedTable, + column: typedTable.age, + }), + ) as postgres.JSONValue + const nick = unwrapResult( + await protectClient.encrypt(`nick-${age}`, { + table: typedTable, + column: typedTable.nickname, + }), + ) as postgres.JSONValue + const act = unwrapResult( + await protectClient.encrypt(true, { + table: typedTable, + column: typedTable.active, + }), + ) as postgres.JSONValue + const [row] = await sql<{ id: number }[]>` + INSERT INTO protect_ci_v3_typed_domains (age, nickname, active, test_run_id) + VALUES ( + ${sql.json(ageCt)}::eql_v3.integer_ord, + ${sql.json(nick)}::eql_v3.text_eq, + ${sql.json(act)}::eql_v3.boolean, + ${TEST_RUN_ID} + ) + RETURNING id + ` + return row.id + } + + const ids = { + thirty: await insertAge(30), + thirtySeven: await insertAge(37), + fortyTwo: await insertAge(42), + } + + // Equality term encrypted with queryType:'equality' — post-fix this resolves + // to the ore (`ob`) term; the SQL `=` operator makes it an equality match. + const equalityTerm = unwrapResult( + await termClient.encryptQuery(37, { + table: typedTable, + column: typedTable.age, + queryType: 'equality', + }), + ) as postgres.JSONValue + + const matched = await sql<{ id: number }[]>` + SELECT id + FROM protect_ci_v3_typed_domains + WHERE test_run_id = ${TEST_RUN_ID} + AND eql_v3.ord_term(age) = eql_v3_internal.ore_block_256(${sql.json(equalityTerm)}::jsonb) + ORDER BY id + ` + // Exactly the age=37 row — not the 30 or 42 rows. + expect(matched.map((row) => row.id)).toEqual([ids.thirtySeven]) + expect(matched.map((row) => row.id)).not.toContain(ids.thirty) + expect(matched.map((row) => row.id)).not.toContain(ids.fortyTwo) + + // A non-matching value selects nothing. + const missTerm = unwrapResult( + await termClient.encryptQuery(99, { + table: typedTable, + column: typedTable.age, + queryType: 'equality', + }), + ) as postgres.JSONValue + const none = await sql<{ id: number }[]>` + SELECT id + FROM protect_ci_v3_typed_domains + WHERE test_run_id = ${TEST_RUN_ID} + AND eql_v3.ord_term(age) = eql_v3_internal.ore_block_256(${sql.json(missTerm)}::jsonb) + ` + expect(none).toHaveLength(0) + }, 30000) +}) diff --git a/packages/stack/__tests__/schema-v3.test-d.ts b/packages/stack/__tests__/schema-v3.test-d.ts new file mode 100644 index 00000000..b39bf352 --- /dev/null +++ b/packages/stack/__tests__/schema-v3.test-d.ts @@ -0,0 +1,348 @@ +import { describe, expectTypeOf, it } from 'vitest' +import { Encryption, type EncryptionClient } from '@/encryption' +import type { + EncryptedTextSearchColumn, + InferEncrypted, + InferPlaintext, +} from '@/eql/v3' +import { encryptedTable, types } from '@/eql/v3' +// v2 column builders — used to prove the v3 table type rejects a v2 column and +// to assert v2 backward-compat against the widened client types. +import { + encryptedColumn, + encryptedField, + encryptedTable as v2EncryptedTable, +} from '@/schema' +import type { Encrypted } from '@/types' + +describe('eql_v3 schema type inference', () => { + it('types.TextSearch returns an EncryptedTextSearchColumn', () => { + const col = types.TextSearch('email') + expectTypeOf(col).toEqualTypeOf<EncryptedTextSearchColumn>() + }) + + it('encryptedTable exposes column builders as typed properties', () => { + const users = encryptedTable('users', { + email: types.TextSearch('email'), + }) + expectTypeOf(users.email).toEqualTypeOf<EncryptedTextSearchColumn>() + expectTypeOf(users.tableName).toBeString() + }) + + it('rejects a v2 EncryptedColumn in a v3 table (nominal private-field mismatch)', () => { + encryptedTable('users', { + // @ts-expect-error - a v2 EncryptedColumn is not an EncryptedTextSearchColumn + email: encryptedColumn('email'), + }) + }) + + it('InferPlaintext maps each column to string', () => { + const users = encryptedTable('users', { + email: types.TextSearch('email'), + name: types.TextSearch('name'), + }) + type Plaintext = InferPlaintext<typeof users> + expectTypeOf<Plaintext>().toEqualTypeOf<{ email: string; name: string }>() + }) + + it('InferEncrypted maps each column to Encrypted', () => { + const users = encryptedTable('users', { + email: types.TextSearch('email'), + }) + type Enc = InferEncrypted<typeof users> + expectTypeOf<Enc>().toEqualTypeOf<{ email: Encrypted }>() + }) + + it('InferPlaintext maps v3 concrete domains to plaintext TypeScript types', () => { + const metrics = encryptedTable('metrics', { + name: types.Text('name'), + age: types.Integer('age'), + active: types.Boolean('active'), + createdAt: types.Timestamp('created_at'), + score: types.Double('score'), + }) + + type Plaintext = InferPlaintext<typeof metrics> + + expectTypeOf<Plaintext>().toEqualTypeOf<{ + name: string + age: number + active: boolean + createdAt: Date + score: number + }>() + }) + + it('v3 domain classes remain nominal by literal domain definition', () => { + const date = types.Date('created_on') + const boolean = types.Boolean('active') + + expectTypeOf(date).not.toEqualTypeOf<typeof boolean>() + + // @ts-expect-error - storage-only boolean is not assignable to storage-only date + const invalid: typeof date = boolean + void invalid + }) +}) + +describe('eql_v3 client integration (type-level acceptance)', () => { + const v3users = encryptedTable('users', { + email: types.TextSearch('email'), + }) + + it('Encryption accepts a v3 schema', () => { + expectTypeOf(Encryption).toBeCallableWith({ schemas: [v3users] }) + }) + + it('encrypt accepts a v3 table + column', () => { + const client = {} as EncryptionClient + expectTypeOf(client.encrypt).toBeCallableWith('alice@example.com', { + table: v3users, + column: v3users.email, + }) + }) + + it('encryptQuery accepts a v3 table + column', () => { + const client = {} as EncryptionClient + expectTypeOf(client.encryptQuery).toBeCallableWith('alice@example.com', { + table: v3users, + column: v3users.email, + }) + }) + + it('decrypt accepts an Encrypted value (round-trip target type; schema-independent)', () => { + const client = {} as EncryptionClient + expectTypeOf(client.decrypt).toBeCallableWith({} as Encrypted) + }) + + it('BACKWARD COMPAT: v2 tables/columns still satisfy the widened types', () => { + const v2users = v2EncryptedTable('users', { + email: encryptedColumn('email').equality(), + }) + expectTypeOf(Encryption).toBeCallableWith({ schemas: [v2users] }) + const client = {} as EncryptionClient + expectTypeOf(client.encrypt).toBeCallableWith('alice@example.com', { + table: v2users, + column: v2users.email, + }) + // a v2 EncryptedColumn is STILL queryable (nominal arm of BuildableQueryColumn) + expectTypeOf(client.encryptQuery).toBeCallableWith('alice@example.com', { + table: v2users, + column: v2users.email, + }) + }) + + it('a non-queryable v2 EncryptedField is encryptable but NOT queryable', () => { + const v2usersWithField = v2EncryptedTable('users', { + profile: { email: encryptedField('email') }, + }) + const client = {} as EncryptionClient + + // POSITIVE: a field IS encryptable (storage path = BuildableColumn) + expectTypeOf(client.encrypt).toBeCallableWith('alice@example.com', { + table: v2usersWithField, + column: v2usersWithField.profile.email, + }) + + // NEGATIVE: a field is NOT queryable. The query path uses + // BuildableQueryColumn, which excludes EncryptedField (no indexes). If the + // query path were instead widened to BuildableColumn (the rejected + // Batch-2/3 design), this call would compile and only fail at runtime with + // "no indexes configured" — so this test guards against that re-widening. + // + // The mismatch is a DEEP object-literal property error, so tsc reports it on + // the `column:` line — the `@ts-expect-error` MUST sit directly above that + // line (not above the call), or you get TS2578 "unused directive" + the real + // error leaking. (Mirror of Task 4's v2-column-rejected test placement.) + client.encryptQuery('alice@example.com', { + table: v2usersWithField, + // @ts-expect-error - EncryptedField is not assignable to BuildableQueryColumn + column: v2usersWithField.profile.email, + }) + }) + + it('encryptQuery accepts queryable v3 columns with explicit capability metadata', () => { + const users = encryptedTable('users', { + emailEq: types.TextEq('email_eq'), + emailMatch: types.TextMatch('email_match'), + emailSearch: types.TextSearch('email_search'), + createdAt: types.TimestampOrd('created_at'), + }) + const client = {} as EncryptionClient + + expectTypeOf(client.encryptQuery).toBeCallableWith('alice@example.com', { + table: users, + column: users.emailEq, + }) + expectTypeOf(client.encryptQuery).toBeCallableWith('ali', { + table: users, + column: users.emailMatch, + queryType: 'freeTextSearch', + }) + expectTypeOf(client.encryptQuery).toBeCallableWith(new Date(), { + table: users, + column: users.createdAt, + queryType: 'orderAndRange', + }) + expectTypeOf(client.encryptQuery).toBeCallableWith('alice@example.com', { + table: users, + column: users.emailSearch, + queryType: 'equality', + }) + }) + + it('encryptQuery rejects storage-only v3 columns at compile time', () => { + const users = encryptedTable('users', { + email: types.Text('email'), + active: types.Boolean('active'), + }) + const client = {} as EncryptionClient + + client.encryptQuery('alice@example.com', { + table: users, + // @ts-expect-error - storage-only v3 text column is not queryable + column: users.email, + }) + + client.encryptQuery(true, { + table: users, + // @ts-expect-error - storage-only v3 boolean column is not queryable + column: users.active, + }) + }) +}) + +describe('eql_v3 model encryption inference', () => { + it('encryptModel and bulkEncryptModels infer encrypted fields from v3 tables', () => { + const users = encryptedTable('users', { + email: types.TextSearch('email'), + active: types.Boolean('active'), + }) + const client = {} as EncryptionClient + + const encryptedOne = client.encryptModel( + { id: 'u1', email: 'alice@example.com', active: true, untouched: 42 }, + users, + ) + expectTypeOf(encryptedOne).toEqualTypeOf< + import('@/encryption').EncryptModelOperation<{ + id: string + email: Encrypted + active: Encrypted + untouched: number + }> + >() + + const encryptedMany = client.bulkEncryptModels( + [{ id: 'u1', email: 'alice@example.com', active: true }], + users, + ) + expectTypeOf(encryptedMany).toEqualTypeOf< + import('@/encryption').BulkEncryptModelsOperation<{ + id: string + email: Encrypted + active: Encrypted + }> + >() + }) + + it('v3 encryptModel preserves unrelated and nullable fields', () => { + const users = encryptedTable('users', { + email: types.TextSearch('email'), + }) + const client = {} as EncryptionClient + + const encrypted = client.encryptModel( + { id: 'u1', email: null as string | null, untouched: 42 }, + users, + ) + + expectTypeOf(encrypted).toEqualTypeOf< + import('@/encryption').EncryptModelOperation<{ + id: string + email: Encrypted | null + untouched: number + }> + >() + }) + + it('encryptModel degrades gracefully for a bare BuildableTable-typed value (no brand)', () => { + // A table passed through a value/param annotated as the structural + // `BuildableTable` (no `_columnType` brand) cannot recover its literal + // column keys. It must degrade to the model unchanged — NOT mark every + // field `Encrypted`. Regression guard: `keyof BuildableTableColumns<...>` + // must resolve to `never` here, not `keyof never` (= string|number|symbol), + // which would wrongly encrypt all fields including `id` and `untouched`. + const usersConcrete = encryptedTable('users', { + email: types.TextSearch('email'), + }) + const table: import('@/types').BuildableTable = usersConcrete + const client = {} as EncryptionClient + + const encrypted = client.encryptModel( + { id: 'u1', email: 'alice@example.com', untouched: 42 }, + table, + ) + expectTypeOf(encrypted).toEqualTypeOf< + import('@/encryption').EncryptModelOperation<{ + id: string + email: string + untouched: number + }> + >() + }) + + it('model inference keys off the property name, not the DB column name (aliased columns)', () => { + // The column's DB name ('created_at') differs from the object property name + // ('occurredAt'). Model inference keys off the PROPERTY name, so `occurredAt` + // must become `Encrypted` while unrelated fields are preserved verbatim. + const events = encryptedTable('events', { + occurredAt: types.Timestamp('created_at'), + }) + const client = {} as EncryptionClient + + const encryptedOne = client.encryptModel( + { id: 'e1', occurredAt: new Date(), label: 'signup' }, + events, + ) + expectTypeOf(encryptedOne).toEqualTypeOf< + import('@/encryption').EncryptModelOperation<{ + id: string + occurredAt: Encrypted + label: string + }> + >() + + const encryptedMany = client.bulkEncryptModels( + [{ id: 'e1', occurredAt: new Date(), label: 'signup' }], + events, + ) + expectTypeOf(encryptedMany).toEqualTypeOf< + import('@/encryption').BulkEncryptModelsOperation<{ + id: string + occurredAt: Encrypted + label: string + }> + >() + }) + + it('v2 encryptModel inference still preserves non-schema fields after widening', () => { + const users = v2EncryptedTable('users', { + email: encryptedColumn('email').equality(), + }) + const client = {} as EncryptionClient + + const encrypted = client.encryptModel( + { id: 'u1', email: 'alice@example.com', age: 30 }, + users, + ) + + expectTypeOf(encrypted).toEqualTypeOf< + import('@/encryption').EncryptModelOperation<{ + id: string + email: Encrypted + age: number + }> + >() + }) +}) diff --git a/packages/stack/__tests__/schema-v3.test.ts b/packages/stack/__tests__/schema-v3.test.ts new file mode 100644 index 00000000..8941a163 --- /dev/null +++ b/packages/stack/__tests__/schema-v3.test.ts @@ -0,0 +1,460 @@ +import { describe, expect, it } from 'vitest' +import { resolveIndexType } from '@/encryption/helpers/infer-index-type' +import { + buildEncryptConfig, + EncryptedTable, + EncryptedTextSearchColumn, + encryptedTable, + types, +} from '@/eql/v3' +import { encryptConfigSchema, encryptedColumn } from '@/schema' +import { type DomainSpec, typedEntries, V3_MATRIX } from './v3-matrix/catalog' + +describe('eql_v3 text_search column', () => { + it('LOAD-BEARING: default build() deep-equals the v2 equality+order+match column', () => { + const v3 = types.TextSearch('email').build() + const v2 = encryptedColumn('email') + .equality() + .orderAndRange() + .freeTextSearch() + .build() + // toStrictEqual: byte-identical, no extra/undefined keys on either side. + expect(v3).toStrictEqual(v2) + }) + + it('.freeTextSearch(opts) overrides each provided key and keeps the rest as defaults', () => { + const built = types + .TextSearch('email') + .freeTextSearch({ + tokenizer: { kind: 'ngram', token_length: 4 }, + k: 8, + m: 4096, + include_original: false, + }) + .build() + expect(built.indexes.match).toEqual({ + tokenizer: { kind: 'ngram', token_length: 4 }, + // omitted -> default downcase filter retained + token_filters: [{ kind: 'downcase' }], + k: 8, + m: 4096, + include_original: false, + }) + }) + + it('.freeTextSearch({ token_filters: [] }) overrides the downcase default with an empty array', () => { + // LOAD-BEARING: `[] ?? default` evaluates to `[]` (an empty array is not + // nullish), so an explicit empty array must OVERRIDE the downcase default, + // not fall back to it. Mirrors v2 (schema-builders.test.ts). + const built = types + .TextSearch('email') + .freeTextSearch({ token_filters: [] }) + .build() + expect(built.indexes.match.token_filters).toEqual([]) + }) + + it('repeated .freeTextSearch() calls are last-call-wins-fully (each re-merges against defaults, not prior state)', () => { + // Each call re-merges against a fresh defaultMatchOpts(), not the + // accumulated matchOpts — so the second call resets k back to its default + // of 6. This is intentional: it mirrors v2 exactly. Pinned here so a future + // "merge against current state" change can't silently slip in. + const built = types + .TextSearch('email') + .freeTextSearch({ k: 8 }) + .freeTextSearch({ m: 4096 }) + .build() + expect(built.indexes.match.k).toBe(6) + expect(built.indexes.match.m).toBe(4096) + }) + + it('.freeTextSearch() with no argument is a no-op: build() equals the default build()', () => { + // Pins the opts === undefined branch: every `opts?.x ?? default` falls + // through, so a bare call must emit exactly the default match block. + expect(types.TextSearch('email').freeTextSearch().build()).toStrictEqual( + types.TextSearch('email').build(), + ) + }) + + it('.freeTextSearch() is tuning-only: unique and ore indexes stay present', () => { + const built = types.TextSearch('email').freeTextSearch({ k: 8 }).build() + expect(built.indexes.unique).toEqual({ token_filters: [] }) + expect(built.indexes.ore).toEqual({}) + }) + + it('built columns share no mutable state: mutating one build() output does not affect another', () => { + // Guards against the shared-defaults aliasing bug: defaults come from a + // per-instance factory and build() deep-clones the match block. + const a = types.TextSearch('a').build() + const b = types.TextSearch('b').build() + + // Mutate every nested level of a's match block. + a.indexes.match.k = 999 + a.indexes.match.token_filters.push({ kind: 'downcase' }) + a.indexes.match.tokenizer = { kind: 'standard' } + + expect(b.indexes.match.k).toBe(6) + expect(b.indexes.match.token_filters).toEqual([{ kind: 'downcase' }]) + expect(b.indexes.match.tokenizer).toEqual({ + kind: 'ngram', + token_length: 3, + }) + + // A second build() of an independent column is also pristine. + const c = types.TextSearch('c').build() + expect(c.indexes.match.k).toBe(6) + expect(c.indexes.match.token_filters).toEqual([{ kind: 'downcase' }]) + }) + + it('clones caller opts on freeTextSearch(): mutating them before build() does not leak', () => { + // build() deep-clones at build time, but if freeTextSearch stored the + // caller's nested tokenizer / token_filters by reference, a caller mutating + // their own opts object between freeTextSearch(opts) and build() would leak + // the mutation into the emitted config. freeTextSearch must clone on write. + const opts = { + tokenizer: { kind: 'ngram' as const, token_length: 3 }, + token_filters: [{ kind: 'downcase' as const }], + } + const col = types.TextSearch('email').freeTextSearch(opts) + + // Mutate the caller's own opts AFTER freeTextSearch but BEFORE build(). + opts.tokenizer.token_length = 999 + opts.token_filters.push({ kind: 'downcase' as const }) + + const built = col.build() + expect(built.indexes.match.tokenizer).toEqual({ + kind: 'ngram', + token_length: 3, + }) + expect(built.indexes.match.token_filters).toEqual([{ kind: 'downcase' }]) + }) +}) + +describe('eql_v3 text_match column', () => { + it('built columns share no mutable state: mutating one build() output does not affect another', () => { + // Same aliasing guard as the text_search test above, but through the base + // class indexesForCapabilities() match clone — text_match has no build() + // override, so a regression there (e.g. sharing a defaultMatchOpts() result + // across builds) would slip past the text_search-only test. + const a = types.TextMatch('a').build() + const b = types.TextMatch('b').build() + + a.indexes.match.k = 999 + a.indexes.match.token_filters.push({ kind: 'downcase' }) + a.indexes.match.tokenizer = { kind: 'standard' } + + expect(b.indexes.match.k).toBe(6) + expect(b.indexes.match.token_filters).toEqual([{ kind: 'downcase' }]) + expect(b.indexes.match.tokenizer).toEqual({ + kind: 'ngram', + token_length: 3, + }) + + // A fresh build() of an independent column is also pristine. + const c = types.TextMatch('c').build() + expect(c.indexes.match.k).toBe(6) + expect(c.indexes.match.token_filters).toEqual([{ kind: 'downcase' }]) + }) +}) + +describe('eql_v3 encryptedTable', () => { + it('creates a table exposing column builders as properties', () => { + const users = encryptedTable('users', { + email: types.TextSearch('email'), + }) + expect(users).toBeInstanceOf(EncryptedTable) + expect(users.tableName).toBe('users') + expect(users.email).toBeInstanceOf(EncryptedTextSearchColumn) + }) + + it('table.email returns the same builder instance passed in', () => { + const emailCol = types.TextSearch('email') + const users = encryptedTable('users', { email: emailCol }) + expect(users.email).toBe(emailCol) + }) + + it.each([ + 'build', + 'tableName', + 'columnBuilders', + '_columnType', + // Inherited Object.prototype members: assigning these as own properties + // would shadow the prototype method/accessor. Guard them too so the + // table object stays well-behaved for reflection / serialization. + 'constructor', + 'toString', + 'valueOf', + 'hasOwnProperty', + ])('throws when a column name (%s) collides with a reserved property', (reserved) => { + expect(() => + encryptedTable('users', { + [reserved]: types.TextSearch(reserved), + }), + ).toThrow(/reserved EncryptedTable property/) + }) + + it('build() assembles { tableName, columns } with built column configs', () => { + const users = encryptedTable('users', { + email: types.TextSearch('email'), + }) + const built = users.build() + expect(built.tableName).toBe('users') + expect(built.columns).toStrictEqual({ + email: { + cast_as: 'string', + indexes: { + unique: { token_filters: [] }, + ore: {}, + match: { + tokenizer: { kind: 'ngram', token_length: 3 }, + token_filters: [{ kind: 'downcase' }], + k: 6, + m: 2048, + include_original: true, + }, + }, + }, + }) + }) + + it('build() throws when two columns resolve to the same DB name (no silent overwrite)', () => { + // Columns are keyed in the built config by DB name (`getName()`), so two JS + // properties whose builders resolve to the same name would silently + // overwrite — the later one wins and the first column's config is lost. + // Fail loudly, matching the reserved-key and duplicate-tableName guards. + const users = encryptedTable('users', { + email: types.TextEq('contact'), + contactEmail: types.TextMatch('contact'), + }) + expect(() => users.build()).toThrow(/duplicate column name "contact"/) + }) + + it('build() surfaces the duplicate DB name through buildEncryptConfig', () => { + const users = encryptedTable('users', { + email: types.TextEq('contact'), + contactEmail: types.TextMatch('contact'), + }) + expect(() => buildEncryptConfig(users)).toThrow( + /duplicate column name "contact"/, + ) + }) +}) + +describe('eql_v3 buildEncryptConfig', () => { + it('zero tables yields an empty config (client-boundary Encryption() still rejects it)', () => { + expect(buildEncryptConfig()).toStrictEqual({ v: 1, tables: {} }) + }) + + it('produces a { v: 1, tables } config', () => { + const users = encryptedTable('users', { + email: types.TextSearch('email'), + }) + const config = buildEncryptConfig(users) + expect(config.v).toBe(1) + expect(config.tables).toHaveProperty('users') + expect(config.tables.users).toHaveProperty('email') + }) + + it('emits a config that passes encryptConfigSchema.parse()', () => { + const users = encryptedTable('users', { + email: types.TextSearch('email'), + }) + const config = buildEncryptConfig(users) + expect(() => encryptConfigSchema.parse(config)).not.toThrow() + }) + + it('supports multiple tables', () => { + const users = encryptedTable('users', { + email: types.TextSearch('email'), + }) + const posts = encryptedTable('posts', { + body: types.TextSearch('body'), + }) + const config = buildEncryptConfig(users, posts) + expect(Object.keys(config.tables).sort()).toEqual(['posts', 'users']) + }) + + it('keys columns by DB name (getName), not the JS property name', () => { + // A camelCase JS key mapping to a snake_case DB column must register the + // config under the DB name — `encrypt`/`decrypt` look columns up by + // `column.getName()`, so keying by the JS property name makes the FFI + // report "column not found in Encrypt config" at encrypt time. + const users = encryptedTable('accounts', { + createdOn: types.Date('created_on'), + lastSeen: types.Timestamp('last_seen'), + }) + const config = buildEncryptConfig(users) + expect(Object.keys(config.tables.accounts).sort()).toEqual([ + 'created_on', + 'last_seen', + ]) + expect(config.tables.accounts).not.toHaveProperty('createdOn') + expect(config.tables.accounts).not.toHaveProperty('lastSeen') + }) + + it('buildColumnKeyMap maps JS property → DB column name', () => { + // The model path matches user models by JS property but must address the + // FFI/config by DB name. `build()` discards the property→name relationship + // (it keys by DB name); `buildColumnKeyMap()` recovers it. + const users = encryptedTable('accounts', { + createdOn: types.Date('created_on'), + lastSeen: types.Timestamp('last_seen'), + email: types.TextSearch('email'), + }) + expect(users.buildColumnKeyMap()).toEqual({ + createdOn: 'created_on', + lastSeen: 'last_seen', + email: 'email', + }) + }) + + it('throws when two tables share the same tableName (no silent drop)', () => { + // v3-only additive guard: keying config.tables by name means a duplicate + // would silently overwrite the earlier table. Fail loudly instead so the + // footgun surfaces at build time. (v2 keeps its silent-overwrite behavior + // unchanged — the no-v2-change constraint.) + const a = encryptedTable('users', { + email: types.TextSearch('email'), + }) + const b = encryptedTable('users', { + name: types.TextSearch('name'), + }) + expect(() => buildEncryptConfig(a, b)).toThrow( + /duplicate table name "users"/, + ) + }) +}) + +// The scalar query types a caller can request against a v3 domain. `searchableJson` +// / steVec are JSONB-only and out of scope for the scalar matrix. +const SCALAR_QUERY_TYPES = [ + 'equality', + 'orderAndRange', + 'freeTextSearch', +] as const + +// The ground-truth for whether `resolveIndexType` accepts a (domain, queryType) +// pair: does the domain carry the index that query resolves to? Derived from the +// catalog's `indexes` data, AMENDED for the equality-via-ORE rule — an +// order-capable column answers equality via its `ore` index, not `unique`. This +// mirrors `resolveIndexType`'s real logic, so it needs no live FFI. +function queryTypeAllowed( + indexes: DomainSpec['indexes'], + queryType: (typeof SCALAR_QUERY_TYPES)[number], +): boolean { + const idx = indexes ?? {} + if (queryType === 'equality') return Boolean(idx.unique || idx.ore) + if (queryType === 'orderAndRange') return Boolean(idx.ore) + return Boolean(idx.match) // freeTextSearch +} + +describe('eql_v3 catalog-driven query capability sweep', () => { + // The Rust harness's `blocker_combos` analog: attempt every scalar queryType + // against every domain and assert the throw/allow outcome the domain's + // configured indexes dictate. Supersedes the two hand-picked cases that used + // to live here — they are now just two of the generated rows. + it.each( + typedEntries(V3_MATRIX).flatMap(([eqlType, spec]) => + SCALAR_QUERY_TYPES.map( + (queryType) => [eqlType, spec, queryType] as const, + ), + ), + )('%s + queryType=%s: gating matches configured indexes', (_eqlType, spec, queryType) => { + const col = spec.builder('value') + if (queryTypeAllowed(spec.indexes, queryType)) { + expect(() => resolveIndexType(col as never, queryType)).not.toThrow() + } else { + // Broad message match: for a blocked equality the resolver reports the + // missing `unique`; for orderAndRange/freeTextSearch the missing ore/match. + expect(() => resolveIndexType(col as never, queryType)).toThrow( + /not configured/, + ) + } + }) + + it.each( + typedEntries(V3_MATRIX).filter( + ([, spec]) => Object.keys(spec.indexes ?? {}).length === 0, + ), + )('%s: querying a storage-only column with no queryType throws', (_eqlType, spec) => { + expect(() => resolveIndexType(spec.builder('value') as never)).toThrow( + /no indexes configured/, + ) + }) + + // Spot-check the exact messages for a queryable-but-misused column, so the + // broad regex above doesn't let a message regression slip through. + it('reports the specific missing index for a match-only column', () => { + const matchOnly = types.TextMatch('body') + expect(() => resolveIndexType(matchOnly, 'equality')).toThrow( + /Index type "unique" is not configured/, + ) + expect(() => resolveIndexType(matchOnly, 'orderAndRange')).toThrow( + /Index type "ore" is not configured/, + ) + }) +}) + +describe('eql_v3 equality via ORE on order-capable columns (regression)', () => { + // The capability contract documents equality as answerable "via `ob`", so a + // numeric/date order-capable column (which has NO `hm`) resolves equality to + // its `ore` index (same term as orderAndRange, distinguished by the SQL `=` + // operator) instead of throwing on the absent `unique` index. (Text order + // domains DO carry `hm` and resolve equality to `unique` instead — see the + // text-order regression below.) + it.each([ + ['integer_ord', types.IntegerOrd], + ['date_ord', types.DateOrd], + ['numeric_ord', types.NumericOrd], + ] as const)('%s resolves equality to the ore index', (_name, builder) => { + expect(resolveIndexType(builder('value'), 'equality')).toEqual({ + indexType: 'ore', + }) + }) + + it('preserves v2: an orderAndRange-only column still throws on equality (no-v2-change)', () => { + // v2 EncryptedColumn has no getQueryCapabilities, so the equality-via-ORE + // branch never fires for it — the equality-without-unique throw is unchanged. + const v2OrderOnly = encryptedColumn('x').orderAndRange() + expect(() => resolveIndexType(v2OrderOnly, 'equality')).toThrow( + /Index type "unique" is not configured/, + ) + }) +}) + +describe('eql_v3 text order domains carry the hm (unique) index (regression)', () => { + // The `eql_v3.text_ord` and `eql_v3.text_ord_ore` SQL domains require BOTH + // `hm` (HMAC) and `ob` (ORE) in the stored ciphertext: text equality is + // HMAC-based (their `eql_v3.eq_term` extracts `hm`), unlike numeric/date order + // domains which answer equality via `ob` and need only ORE. So text order + // columns must emit `unique` (hm) IN ADDITION to `ore` (ob), or a real INSERT + // fails with `value for domain eql_v3.text_ord_ore violates check constraint`. + it.each([ + ['text_ord_ore', types.TextOrdOre], + ['text_ord', types.TextOrd], + ] as const)('%s emits both unique (hm) and ore (ob)', (_name, builder) => { + expect(builder('c').build().indexes).toStrictEqual({ + unique: { token_filters: [] }, + ore: {}, + }) + }) + + it.each([ + ['integer_ord_ore', types.IntegerOrdOre], + ['integer_ord', types.IntegerOrd], + ['date_ord_ore', types.DateOrdOre], + ['numeric_ord', types.NumericOrd], + ] as const)('%s (numeric/date order) emits ore only — no unique', (_name, builder) => { + expect(builder('c').build().indexes).toStrictEqual({ ore: {} }) + }) + + // With `unique` present, text order equality resolves to the hm index (not + // ORE): `resolvesEqualityViaOre` only fires when `unique` is ABSENT. + it.each([ + ['text_ord_ore', types.TextOrdOre], + ['text_ord', types.TextOrd], + ] as const)('%s resolves equality to the unique (hm) index', (_name, builder) => { + expect(resolveIndexType(builder('value'), 'equality')).toEqual({ + indexType: 'unique', + }) + }) +}) diff --git a/packages/stack/__tests__/supabase-v3-builder.test.ts b/packages/stack/__tests__/supabase-v3-builder.test.ts new file mode 100644 index 00000000..5fa9d8d0 --- /dev/null +++ b/packages/stack/__tests__/supabase-v3-builder.test.ts @@ -0,0 +1,563 @@ +import { describe, expect, it } from 'vitest' +import type { EncryptionClient } from '@/encryption' +import { encryptedTable, types } from '@/eql/v3' +import { encryptedColumn, encryptedTable as encryptedTableV2 } from '@/schema' +import { encryptedSupabase, encryptedSupabaseV3 } from '@/supabase' + +// --------------------------------------------------------------------------- +// Mocks +// +// The builders only touch a narrow slice of the encryption client and the +// supabase client, so both are simulated: the encryption mock produces +// deterministic fake envelopes (carrying the plaintext in `pt` so the fake +// decrypt can undo them), and the supabase mock records every builder call. +// This pins the WIRE ENCODING each dialect produces — the part of the adapter +// that CI can verify without a live Supabase project. +// --------------------------------------------------------------------------- + +type FakeEnvelope = { + v: 3 + i: { t: string; c: string } + c: string + hm: string + pt: unknown +} + +function fakeEnvelope(value: unknown, column: string): FakeEnvelope { + const pt = value instanceof Date ? value.toISOString() : value + return { + v: 3, + i: { t: 'tbl', c: column }, + c: `ct:${String(pt)}`, + hm: `hm:${String(pt)}`, + pt, + } +} + +function isFakeEnvelope(value: unknown): value is FakeEnvelope { + return ( + typeof value === 'object' && + value !== null && + 'pt' in value && + 'c' in value && + 'hm' in value + ) +} + +/** A chainable operation resolving to `{ data }`, like the real ones. */ +function operation<T>(data: T) { + const op = { + withLockContext: () => op, + audit: () => op, + then: ( + onfulfilled?: ((value: { data: T }) => unknown) | null, + onrejected?: ((reason: unknown) => unknown) | null, + ) => Promise.resolve({ data }).then(onfulfilled, onrejected), + } + return op +} + +type SchemaLike = { + build(): { columns: Record<string, unknown> } + buildColumnKeyMap?(): Record<string, string> +} + +function createMockEncryptionClient() { + const encryptedProps = (table: SchemaLike): string[] => + table.buildColumnKeyMap + ? Object.keys(table.buildColumnKeyMap()) + : Object.keys(table.build().columns) + + const client = { + encrypt: (value: unknown, opts: { column: { getName(): string } }) => + operation(fakeEnvelope(value, opts.column.getName())), + + // v2 filter path: batch query terms as composite literals + encryptQuery: (terms: Array<{ value: unknown }>) => + operation(terms.map((t) => `("${String(t.value)}")`)), + + encryptModel: (model: Record<string, unknown>, table: SchemaLike) => { + const props = encryptedProps(table) + const out: Record<string, unknown> = { ...model } + for (const prop of props) { + if (out[prop] != null) out[prop] = fakeEnvelope(out[prop], prop) + } + return operation(out) + }, + + bulkEncryptModels: ( + models: Record<string, unknown>[], + table: SchemaLike, + ) => { + const props = encryptedProps(table) + return operation( + models.map((model) => { + const out: Record<string, unknown> = { ...model } + for (const prop of props) { + if (out[prop] != null) out[prop] = fakeEnvelope(out[prop], prop) + } + return out + }), + ) + }, + + decryptModel: (model: Record<string, unknown>) => { + const out: Record<string, unknown> = {} + for (const [key, value] of Object.entries(model)) { + out[key] = isFakeEnvelope(value) ? value.pt : value + } + return operation(out) + }, + + bulkDecryptModels: (models: Record<string, unknown>[]) => + operation( + models.map((model) => { + const out: Record<string, unknown> = {} + for (const [key, value] of Object.entries(model)) { + out[key] = isFakeEnvelope(value) ? value.pt : value + } + return out + }), + ), + } + + return client as unknown as EncryptionClient +} + +type RecordedCall = { method: string; args: unknown[] } + +function createMockSupabase(resultData: unknown = []) { + const calls: RecordedCall[] = [] + // biome-ignore lint/suspicious/noExplicitAny: test double for the supabase query builder + const qb: any = {} + const methods = [ + 'select', + 'insert', + 'update', + 'upsert', + 'delete', + 'eq', + 'neq', + 'gt', + 'gte', + 'lt', + 'lte', + 'like', + 'ilike', + 'is', + 'in', + 'filter', + 'not', + 'or', + 'match', + 'order', + 'limit', + 'range', + 'single', + 'maybeSingle', + 'csv', + 'abortSignal', + 'throwOnError', + ] + for (const method of methods) { + qb[method] = (...args: unknown[]) => { + calls.push({ method, args }) + return qb + } + } + qb.then = ( + onfulfilled?: ((value: unknown) => unknown) | null, + onrejected?: ((reason: unknown) => unknown) | null, + ) => + Promise.resolve({ + data: resultData, + error: null, + count: null, + status: 200, + statusText: 'OK', + }).then(onfulfilled, onrejected) + + const client = { from: (_table: string) => qb } + const callsFor = (method: string) => calls.filter((c) => c.method === method) + + return { client, calls, callsFor } +} + +// --------------------------------------------------------------------------- +// Schemas +// --------------------------------------------------------------------------- + +const users = encryptedTable('users', { + email: types.TextSearch('email'), + nickname: types.TextEq('nickname'), + amount: types.IntegerOrd('amount'), + createdAt: types.TimestampOrd('created_at'), + active: types.Boolean('active'), +}) + +const usersV2 = encryptedTableV2('users', { + email: encryptedColumn('email').freeTextSearch().equality(), + age: encryptedColumn('age').dataType('number').equality().orderAndRange(), +}) + +// Explicit row type: the default `Row` is exactly the table's plaintext shape, +// so passthrough columns (id, note) need an explicit `Row` to be filterable / +// insertable at the type level. +type UserRow = { + id: number + email: string + nickname: string + amount: number + createdAt: Date + active: boolean + note: string +} + +function v3Instance(resultData: unknown = []) { + const supabase = createMockSupabase(resultData) + const es = encryptedSupabaseV3({ + encryptionClient: createMockEncryptionClient(), + supabaseClient: supabase.client, + }) + const from = () => es.from<typeof users, UserRow>('users', users) + return { es, from, supabase } +} + +// --------------------------------------------------------------------------- +// v3 dialect +// --------------------------------------------------------------------------- + +describe('encryptedSupabaseV3 wire encoding', () => { + it('inserts the raw encrypted payload keyed by DB column name (no composite wrap)', async () => { + const { from, supabase } = v3Instance() + + const createdAt = new Date('2026-01-02T03:04:05.000Z') + await from().insert({ email: 'a@b.com', createdAt, note: 'plain' }) + + const [insert] = supabase.callsFor('insert') + expect(insert).toBeDefined() + const body = insert.args[0] as Record<string, unknown> + + // Property createdAt lands in DB column created_at + expect(Object.keys(body).sort()).toEqual(['created_at', 'email', 'note']) + // Raw envelope — NOT v2's `{ data: ... }` composite wrap + expect(isFakeEnvelope(body.email)).toBe(true) + expect((body.email as Record<string, unknown>).data).toBeUndefined() + expect(isFakeEnvelope(body.created_at)).toBe(true) + expect(body.note).toBe('plain') + }) + + it('bulk-inserts raw encrypted payloads keyed by DB column name', async () => { + const { from, supabase } = v3Instance() + + await from().insert([{ email: 'a@b.com' }, { email: 'b@c.com' }]) + + const [insert] = supabase.callsFor('insert') + const body = insert.args[0] as Record<string, unknown>[] + expect(body).toHaveLength(2) + expect(isFakeEnvelope(body[0].email)).toBe(true) + expect(isFakeEnvelope(body[1].email)).toBe(true) + }) + + it('adds ::jsonb casts and aliases property names to DB names in select', async () => { + const { from, supabase } = v3Instance() + + await from().select('id, email, createdAt') + + const [select] = supabase.callsFor('select') + expect(select.args[0]).toBe('id, email::jsonb, createdAt:created_at::jsonb') + }) + + it('encrypts equality operands as full-envelope jsonb text', async () => { + const { from, supabase } = v3Instance() + + await from().select('id, email').eq('email', 'a@b.com') + + const eqCalls = supabase.callsFor('eq') + expect(eqCalls).toHaveLength(1) + const [column, term] = eqCalls[0].args + expect(column).toBe('email') + // The operand must be the FULL storage envelope (v/i/c + index terms) so + // it satisfies the eql_v3 domain CHECK when Postgres coerces it. + const parsed = JSON.parse(term as string) + expect(parsed.c).toBeDefined() + expect(parsed.i).toBeDefined() + expect(parsed.hm).toBeDefined() + }) + + it('passes non-encrypted filters through untouched', async () => { + const { from, supabase } = v3Instance() + + await from().select('id, email').eq('id', 42) + + const eqCalls = supabase.callsFor('eq') + expect(eqCalls[0].args).toEqual(['id', 42]) + }) + + it('maps property names to DB names in range filters', async () => { + const { from, supabase } = v3Instance() + + const lowerBound = new Date('2026-01-01T00:00:00.000Z') + await from().select('id, createdAt').gte('createdAt', lowerBound) + + const [gte] = supabase.callsFor('gte') + expect(gte.args[0]).toBe('created_at') + expect(JSON.parse(gte.args[1] as string).c).toBeDefined() + }) + + it('emits encrypted like/ilike as PostgREST cs (bloom-filter containment)', async () => { + const { from, supabase } = v3Instance() + + await from().select('id, email').like('email', 'a@b') + await from().select('id, email').ilike('email', 'a@b') + + const filterCalls = supabase.callsFor('filter') + expect(filterCalls).toHaveLength(2) + for (const call of filterCalls) { + expect(call.args[0]).toBe('email') + expect(call.args[1]).toBe('cs') + expect(JSON.parse(call.args[2] as string).c).toBeDefined() + } + // No bare like/ilike reached PostgREST for the encrypted column + expect(supabase.callsFor('like')).toHaveLength(0) + expect(supabase.callsFor('ilike')).toHaveLength(0) + }) + + it('keeps like on plain columns as like', async () => { + const { from, supabase } = v3Instance() + + await from().select('id, email').like('note', '%x%') + + expect(supabase.callsFor('like')).toHaveLength(1) + expect(supabase.callsFor('filter')).toHaveLength(0) + }) + + it('maps not(like) on encrypted columns to not(cs)', async () => { + const { from, supabase } = v3Instance() + + await from().select('id, email').not('email', 'like', 'a@b') + + const [not] = supabase.callsFor('not') + expect(not.args[0]).toBe('email') + expect(not.args[1]).toBe('cs') + }) + + it('encrypts each element of an in() filter', async () => { + const { from, supabase } = v3Instance() + + await from().select('id, nickname').in('nickname', ['ada', 'grace']) + + const [inCall] = supabase.callsFor('in') + expect(inCall.args[0]).toBe('nickname') + const values = inCall.args[1] as string[] + expect(values).toHaveLength(2) + expect(JSON.parse(values[0]).pt).toBe('ada') + expect(JSON.parse(values[1]).pt).toBe('grace') + }) + + it('maps match() keys to DB names and encrypts values', async () => { + const { from, supabase } = v3Instance() + + await from().select('id, nickname').match({ nickname: 'ada', id: 7 }) + + const [match] = supabase.callsFor('match') + const query = match.args[0] as Record<string, unknown> + expect(JSON.parse(query.nickname as string).pt).toBe('ada') + expect(query.id).toBe(7) + }) + + it('rejects a query type the column does not support', async () => { + const { from } = v3Instance() + + // nickname is eql_v3.text_eq — equality only, no order/range + const { error, status } = await from() + .select('id, nickname') + .gte('nickname', 'a') + + expect(status).toBe(500) + expect(error?.message).toContain('does not support orderAndRange') + }) + + it('rejects filters on storage-only columns', async () => { + const { from } = v3Instance() + + // active is eql_v3.boolean — storage only + const { error, status } = await from() + .select('id') + // biome-ignore lint/suspicious/noExplicitAny: intentionally bypassing the type guard to prove the runtime guard + .eq('active' as any, true as any) + + expect(status).toBe(500) + expect(error?.message).toContain('does not support equality') + }) + + it('reconstructs Date values from cast_as on decrypted rows', async () => { + const rows = [ + { + id: 1, + email: fakeEnvelope('a@b.com', 'email'), + createdAt: fakeEnvelope( + new Date('2026-01-02T03:04:05.000Z'), + 'created_at', + ), + }, + ] + const { from } = v3Instance(rows) + + const { data, error } = await from().select('id, email, createdAt') + + expect(error).toBeNull() + expect(data).toHaveLength(1) + expect(data![0].email).toBe('a@b.com') + expect(data![0].createdAt).toBeInstanceOf(Date) + expect((data![0].createdAt as Date).toISOString()).toBe( + '2026-01-02T03:04:05.000Z', + ) + }) + + it('reconstructs Date values selected under a user-chosen PostgREST alias', async () => { + const rows = [ + { + id: 1, + ts: fakeEnvelope(new Date('2026-01-02T03:04:05.000Z'), 'created_at'), + }, + ] + const { from, supabase } = v3Instance(rows) + + const { data, error } = await from().select('id, ts:createdAt') + + // The alias resolves through the property to the DB column… + const [select] = supabase.callsFor('select') + expect(select.args[0]).toBe('id, ts:created_at::jsonb') + + // …and the aliased key still gets cast_as-driven Date reconstruction. + expect(error).toBeNull() + const row = data![0] as Record<string, unknown> + expect(row.ts).toBeInstanceOf(Date) + expect((row.ts as Date).toISOString()).toBe('2026-01-02T03:04:05.000Z') + }) + + it('rebuilds structured or() conditions with DB names, cs remap, and encrypted operands', async () => { + const { from, supabase } = v3Instance() + + await from() + .select('id, email, createdAt') + .or([ + { column: 'email', op: 'ilike', value: 'a@b' }, + { column: 'createdAt', op: 'gte', value: new Date('2026-01-01') }, + { column: 'id', op: 'eq', value: 7 }, + ]) + + const [or] = supabase.callsFor('or') + const orString = or.args[0] as string + + // Encrypted ilike → cs, property → DB name, operand = quoted envelope + expect(orString).toContain('email.cs.') + expect(orString).not.toContain('email.ilike.') + expect(orString).toContain('created_at.gte.') + // Plain condition passes through untouched + expect(orString).toContain('id.eq.7') + // Encrypted operands are the full envelope (double-quoted by the + // or-string formatter because JSON contains reserved characters) + expect(orString).toContain('"{') + }) + + it('rebuilds string-form or() with encrypted conditions remapped', async () => { + const { from, supabase } = v3Instance() + + await from().select('id, email').or('email.eq.a@b.com,id.eq.7') + + const [or] = supabase.callsFor('or') + const orString = or.args[0] as string + // The encrypted value is substituted; the plain condition survives as-is + expect(orString).toContain('email.eq."{') + expect(orString).toContain('id.eq.7') + }) + + it('passes a string-form or() through verbatim when no condition is encrypted', async () => { + const { from, supabase } = v3Instance() + + await from().select('id').or('id.eq.7,note.eq.x') + + const [or] = supabase.callsFor('or') + expect(or.args[0]).toBe('id.eq.7,note.eq.x') + }) + + it('rejects a null operand with a pointer to .is()', async () => { + const { from } = v3Instance() + + const { error, status } = await from() + .select('id, email') + // biome-ignore lint/suspicious/noExplicitAny: intentionally bypassing the type guard to prove the runtime guard + .eq('email', null as any) + + expect(status).toBe(500) + expect(error?.message).toContain('null filter value') + expect(error?.message).toContain(".is('email', null)") + }) + + it('still routes .is() null checks through untouched', async () => { + const { from, supabase } = v3Instance() + + await from().select('id, email').is('email', null) + + const [isCall] = supabase.callsFor('is') + expect(isCall.args).toEqual(['email', null]) + }) +}) + +// --------------------------------------------------------------------------- +// v2 regression — the dialect seams must leave the v2 wire encoding untouched +// --------------------------------------------------------------------------- + +describe('encryptedSupabase (v2) wire encoding is unchanged by the dialect seams', () => { + function v2Instance(resultData: unknown = []) { + const supabase = createMockSupabase(resultData) + const es = encryptedSupabase({ + encryptionClient: createMockEncryptionClient(), + supabaseClient: supabase.client, + }) + return { es, supabase } + } + + it('wraps encrypted mutation values in the { data } composite shape', async () => { + const { es, supabase } = v2Instance() + + await es.from('users', usersV2).insert({ email: 'a@b.com', note: 'x' }) + + const [insert] = supabase.callsFor('insert') + const body = insert.args[0] as Record<string, unknown> + expect(body.email).toHaveProperty('data') + expect(isFakeEnvelope((body.email as Record<string, unknown>).data)).toBe( + true, + ) + expect(body.note).toBe('x') + }) + + it('encodes filter terms as composite literals via encryptQuery', async () => { + const { es, supabase } = v2Instance() + + await es.from('users', usersV2).select('id, email').eq('email', 'a@b.com') + + const [eq] = supabase.callsFor('eq') + expect(eq.args).toEqual(['email', '("a@b.com")']) + }) + + it('keeps like on encrypted columns as like', async () => { + const { es, supabase } = v2Instance() + + await es.from('users', usersV2).select('id, email').like('email', 'a@b') + + expect(supabase.callsFor('like')).toHaveLength(1) + expect(supabase.callsFor('filter')).toHaveLength(0) + }) + + it('adds plain ::jsonb casts without aliasing', async () => { + const { es, supabase } = v2Instance() + + await es.from('users', usersV2).select('id, email, age') + + const [select] = supabase.callsFor('select') + expect(select.args[0]).toBe('id, email::jsonb, age::jsonb') + }) +}) diff --git a/packages/stack/__tests__/supabase-v3.test-d.ts b/packages/stack/__tests__/supabase-v3.test-d.ts new file mode 100644 index 00000000..2c709f08 --- /dev/null +++ b/packages/stack/__tests__/supabase-v3.test-d.ts @@ -0,0 +1,135 @@ +import { describe, expectTypeOf, it } from 'vitest' +import type { EncryptionClient } from '@/encryption' +import { encryptedTable, types } from '@/eql/v3' +import { encryptedColumn, encryptedTable as v2EncryptedTable } from '@/schema' +import { + type EncryptedQueryBuilder, + type EncryptedSupabaseResponse, + encryptedSupabase, + encryptedSupabaseV3, + type SupabaseClientLike, +} from '@/supabase' + +declare const encryptionClient: EncryptionClient +declare const supabaseClient: SupabaseClientLike + +const users = encryptedTable('users', { + email: types.TextSearch('email'), + amount: types.IntegerOrd('amount'), + createdAt: types.TimestampOrd('created_at'), + active: types.Boolean('active'), +}) + +type UserRow = { + id: number + email: string + amount: number + createdAt: Date + active: boolean + note: string +} + +const es = encryptedSupabaseV3({ encryptionClient, supabaseClient }) + +describe('encryptedSupabaseV3 typing', () => { + it('defaults rows to exactly InferPlaintext of the table', async () => { + const builder = es.from('users', users) + const { data } = await builder.select('id, email, amount') + + // Schema columns carry their domain plaintext types + expectTypeOf(data![0].email).toEqualTypeOf<string>() + expectTypeOf(data![0].amount).toEqualTypeOf<number>() + expectTypeOf(data![0].createdAt).toEqualTypeOf<Date>() + expectTypeOf(data![0].active).toEqualTypeOf<boolean>() + }) + + it('narrows filter keys in the DEFAULT-Row case (no index-signature widening)', () => { + const builder = es.from('users', users) + + builder.eq('email', 'a@b.com') + builder.gte('amount', 10) + + // Storage-only column: excluded even without an explicit Row — the + // default Row is exactly InferPlaintext, so V3FilterableKeys stays narrow + // instead of collapsing to string. + // @ts-expect-error — storage-only column is excluded from filter keys + builder.eq('active', true) + + // Passthrough (non-schema) columns need an explicit Row to be filterable. + // @ts-expect-error — not a schema column; pass an explicit Row type + builder.eq('id', 1) + }) + + it('pins filter value types to the column plaintext with an explicit row type', () => { + const builder = es.from<typeof users, UserRow>('users', users) + + builder.eq('email', 'a@b.com') + builder.gte('amount', 10) + builder.gte('createdAt', new Date()) + builder.eq('id', 1) + + // Wrong value type for a column + // @ts-expect-error — email is a string column + builder.eq('email', 42) + // @ts-expect-error — amount is a number column + builder.gte('amount', 'ten') + }) + + it('rejects filters on storage-only columns at the type level', () => { + const builder = es.from<typeof users, UserRow>('users', users) + + // active is eql_v3.boolean — storage-only, not filterable + // @ts-expect-error — storage-only column is excluded from filter keys + builder.eq('active', true) + // @ts-expect-error — storage-only column is excluded from filter keys + builder.is('active', true) + // match() is FK-narrowed like every other filter method + builder.match({ email: 'a@b.com', amount: 3 }) + // @ts-expect-error — storage-only column is excluded from match() + builder.match({ active: true }) + }) + + it('accepts plaintext model values on insert', () => { + const builder = es.from<typeof users, UserRow>('users', users) + + builder.insert({ email: 'a@b.com', amount: 3, createdAt: new Date() }) + builder.insert([{ email: 'a@b.com' }, { note: 'plain' }]) + + // @ts-expect-error — createdAt is a Date column + builder.insert({ createdAt: 'not-a-date' }) + }) + + it('resolves responses to the row type', () => { + const builder = es.from<typeof users, UserRow>('users', users) + expectTypeOf(builder.select('id, email')).resolves.toEqualTypeOf< + EncryptedSupabaseResponse<UserRow[]> + >() + }) + + it('rejects a v2 schema', () => { + const v2Table = v2EncryptedTable('users', { + email: encryptedColumn('email').equality(), + }) + + // @ts-expect-error — encryptedSupabaseV3 only accepts v3 tables + es.from('users', v2Table) + }) +}) + +describe('encryptedSupabase (v2) typing is unchanged', () => { + it('keeps the single-generic builder shape', () => { + const esV2 = encryptedSupabase({ encryptionClient, supabaseClient }) + const v2Table = v2EncryptedTable('users', { + email: encryptedColumn('email').equality(), + }) + + type V2Row = { id: number; email: string } + const builder = esV2.from<V2Row>('users', v2Table) + expectTypeOf(builder).toEqualTypeOf<EncryptedQueryBuilder<V2Row>>() + + builder.eq('email', 'a@b.com') + builder.eq('id', 1) + // @ts-expect-error — not a row key + builder.eq('missing', 1) + }) +}) diff --git a/packages/stack/__tests__/supabase-v3.test.ts b/packages/stack/__tests__/supabase-v3.test.ts new file mode 100644 index 00000000..9afd4e56 --- /dev/null +++ b/packages/stack/__tests__/supabase-v3.test.ts @@ -0,0 +1,351 @@ +import 'dotenv/config' + +import { createClient } from '@supabase/supabase-js' +import postgres from 'postgres' +import { afterAll, beforeAll, describe, expect, it } from 'vitest' +import { encryptedTable, types } from '@/eql/v3' +import { Encryption } from '@/index' +import { encryptedSupabaseV3 } from '@/supabase' +import { installEqlV3IfNeeded } from './helpers/eql-v3' + +// Mirror of supabase.test.ts for EQL v3 native domains. Needs a live Supabase +// project, so the suite is skipped unless SUPABASE_URL, SUPABASE_ANON_KEY, and +// DATABASE_URL are all set (plus the CS_* credentials Encryption() needs — +// same as every live suite). +// +// MANUAL PREREQUISITE (same class of step v2 needs for eql_v2): the `eql_v3` +// schema must be added to the Supabase dashboard's **Exposed schemas** +// (Settings → API → Exposed schemas). Without it the custom operators on the +// eql_v3.* domains are not on PostgREST's search_path and bare `col = term` +// filters silently fall back to base jsonb comparison — wrong results, no +// error. The grants themselves are applied automatically by +// installEqlV3IfNeeded below. +const SUPABASE_ENABLED = Boolean( + process.env.SUPABASE_URL && + process.env.SUPABASE_ANON_KEY && + process.env.DATABASE_URL, +) + +const supabase = SUPABASE_ENABLED + ? createClient(process.env.SUPABASE_URL!, process.env.SUPABASE_ANON_KEY!) + : (undefined as unknown as ReturnType<typeof createClient>) + +// include_original: false on the match index is load-bearing for the live +// like/ilike tests: v3 filter operands are full storage envelopes (every +// eql_v3 domain CHECK requires the storage keys), and with include_original +// the operand's bloom would carry the whole pattern as an extra token that +// only matches when the pattern equals the stored value. +const table = encryptedTable('protect-ci-v3', { + email: types.TextSearch('email').freeTextSearch({ include_original: false }), + age: types.IntegerOrd('age'), + registeredAt: types.TimestampOrd('registered_at'), +}) + +type ProtectCiV3Row = { + id: number + email: string + age: number + registeredAt: Date + otherField: string + test_run_id: string +} + +const TEST_RUN_ID = `test-run-${Date.now()}-${Math.random().toString(36).slice(2, 8)}` + +const insertedIds: number[] = [] + +beforeAll(async () => { + if (!SUPABASE_ENABLED) return + + const sql = postgres(process.env.DATABASE_URL as string, { prepare: false }) + try { + // Supabase-aware install: opclass-stripped bundle + eql_v3 grants for the + // anon / authenticated / service_role roles. + await installEqlV3IfNeeded(sql, { supabase: true }) + + await sql` + CREATE TABLE IF NOT EXISTS "protect-ci-v3" ( + id INTEGER PRIMARY KEY GENERATED ALWAYS AS IDENTITY, + email eql_v3.text_search, + age eql_v3.integer_ord, + registered_at eql_v3.timestamp_ord, + "otherField" TEXT, + created_at TIMESTAMP DEFAULT NOW(), + test_run_id TEXT + ) + ` + await sql`GRANT ALL ON "protect-ci-v3" TO anon, authenticated, service_role` + await sql`NOTIFY pgrst, 'reload schema'` + } finally { + await sql.end() + } + + const { error } = await supabase + .from('protect-ci-v3') + .delete() + .eq('test_run_id', TEST_RUN_ID) + + if (error) { + console.warn(`[protect]: Failed to clean up test data: ${error.message}`) + } +}, 60000) + +afterAll(async () => { + if (!SUPABASE_ENABLED) return + if (insertedIds.length > 0) { + const { error } = await supabase + .from('protect-ci-v3') + .delete() + .in('id', insertedIds) + if (error) { + console.error(`[protect]: Failed to clean up test data: ${error.message}`) + } + } +}, 30000) + +describe.skipIf(!SUPABASE_ENABLED)( + 'supabase (encryptedSupabaseV3 wrapper, eql_v3 domains)', + () => { + async function makeInstance() { + const client = await Encryption({ schemas: [table] }) + return encryptedSupabaseV3({ + encryptionClient: client, + supabaseClient: supabase, + }) + } + + it('inserts and selects an encrypted text_search value', async () => { + const es = await makeInstance() + const plaintext = 'hello-v3@example.com' + + const { data: insertedData, error: insertError } = await es + .from<typeof table, ProtectCiV3Row>('protect-ci-v3', table) + .insert({ email: plaintext, test_run_id: TEST_RUN_ID }) + .select('id') + + if (insertError) throw new Error(`[protect]: ${insertError.message}`) + insertedIds.push(insertedData![0].id) + + const { data, error } = await es + .from<typeof table, ProtectCiV3Row>('protect-ci-v3', table) + .select('id, email') + .eq('id', insertedData![0].id) + + if (error) throw new Error(`[protect]: ${error.message}`) + expect(data).toHaveLength(1) + expect(data![0].email).toBe(plaintext) + }, 30000) + + it('round-trips a model including a Date column (reconstructRow parity)', async () => { + const es = await makeInstance() + const registeredAt = new Date('2026-03-04T05:06:07.000Z') + const model = { + email: 'dates-v3@example.com', + registeredAt, + otherField: 'not encrypted', + } + + const { data: insertedData, error: insertError } = await es + .from<typeof table, ProtectCiV3Row>('protect-ci-v3', table) + .insert({ ...model, test_run_id: TEST_RUN_ID }) + .select('id') + + if (insertError) throw new Error(`[protect]: ${insertError.message}`) + insertedIds.push(insertedData![0].id) + + const { data, error } = await es + .from<typeof table, ProtectCiV3Row>('protect-ci-v3', table) + .select('id, email, registeredAt, otherField') + .eq('id', insertedData![0].id) + + if (error) throw new Error(`[protect]: ${error.message}`) + expect(data).toHaveLength(1) + expect(data![0].email).toBe(model.email) + expect(data![0].otherField).toBe(model.otherField) + // Date columns are reconstructed from cast_as, not returned as strings + expect(data![0].registeredAt).toBeInstanceOf(Date) + expect(data![0].registeredAt.toISOString()).toBe( + registeredAt.toISOString(), + ) + }, 30000) + + it('inserts and selects bulk encrypted models', async () => { + const es = await makeInstance() + const models = [ + { email: 'bulk-v3-1@example.com', otherField: 'plain 1' }, + { email: 'bulk-v3-2@example.com', otherField: 'plain 2' }, + ] + + const { data: insertedData, error: insertError } = await es + .from<typeof table, ProtectCiV3Row>('protect-ci-v3', table) + .insert(models.map((m) => ({ ...m, test_run_id: TEST_RUN_ID }))) + .select('id') + + if (insertError) throw new Error(`[protect]: ${insertError.message}`) + insertedIds.push(...insertedData!.map((d) => d.id)) + + const { data, error } = await es + .from<typeof table, ProtectCiV3Row>('protect-ci-v3', table) + .select('id, email, otherField') + .in( + 'id', + insertedData!.map((d) => d.id), + ) + + if (error) throw new Error(`[protect]: ${error.message}`) + expect( + data!.map((d) => ({ email: d.email, otherField: d.otherField })), + ).toEqual(models) + }, 30000) + + it('filters a text_search column by equality (full-envelope operand)', async () => { + const es = await makeInstance() + const target = `eq-v3-${TEST_RUN_ID}@example.com` + + const { data: insertedData, error: insertError } = await es + .from<typeof table, ProtectCiV3Row>('protect-ci-v3', table) + .insert([ + { email: target, test_run_id: TEST_RUN_ID }, + { + email: `other-${TEST_RUN_ID}@example.com`, + test_run_id: TEST_RUN_ID, + }, + ]) + .select('id') + + if (insertError) throw new Error(`[protect]: ${insertError.message}`) + insertedIds.push(...insertedData!.map((d) => d.id)) + + // The equality operand must satisfy the text_search domain CHECK + // (hm+ob+bf+ciphertext) — a narrowed hm-only term raises 23514. The + // adapter sends the full envelope; the eq operator matches by hmac. + const { data, error } = await es + .from<typeof table, ProtectCiV3Row>('protect-ci-v3', table) + .select('id, email') + .eq('email', target) + .eq('test_run_id', TEST_RUN_ID) + + if (error) throw new Error(`[protect]: ${error.message}`) + expect(data).toHaveLength(1) + expect(data![0].email).toBe(target) + }, 30000) + + it('free-text searches a text_search column via like → cs (bloom containment)', async () => { + const es = await makeInstance() + const needle = `ftx${TEST_RUN_ID.slice(-6)}` + + const { data: insertedData, error: insertError } = await es + .from<typeof table, ProtectCiV3Row>('protect-ci-v3', table) + .insert([ + { email: `alpha-${needle}@example.com`, test_run_id: TEST_RUN_ID }, + { email: `beta-nomatch@example.com`, test_run_id: TEST_RUN_ID }, + ]) + .select('id') + + if (insertError) throw new Error(`[protect]: ${insertError.message}`) + insertedIds.push(...insertedData!.map((d) => d.id)) + + const { data, error } = await es + .from<typeof table, ProtectCiV3Row>('protect-ci-v3', table) + .select('id, email') + .like('email', needle) + .eq('test_run_id', TEST_RUN_ID) + + if (error) throw new Error(`[protect]: ${error.message}`) + expect(data).toHaveLength(1) + expect(data![0].email).toContain(needle) + }, 30000) + + it('filters an integer_ord column by equality', async () => { + const es = await makeInstance() + + const { data: insertedData, error: insertError } = await es + .from<typeof table, ProtectCiV3Row>('protect-ci-v3', table) + .insert([ + { age: 37, test_run_id: TEST_RUN_ID }, + { age: 42, test_run_id: TEST_RUN_ID }, + ]) + .select('id') + + if (insertError) throw new Error(`[protect]: ${insertError.message}`) + insertedIds.push(...insertedData!.map((d) => d.id)) + + const { data, error } = await es + .from<typeof table, ProtectCiV3Row>('protect-ci-v3', table) + .select('id, age') + .eq('age', 37) + .eq('test_run_id', TEST_RUN_ID) + + if (error) throw new Error(`[protect]: ${error.message}`) + expect(data).toHaveLength(1) + expect(data![0].age).toBe(37) + }, 30000) + + // First-of-its-kind coverage: the v2 suite historically had no encrypted + // range test on Supabase (a matching v2 range test now lives in + // supabase.test.ts). Real ORE terms require live ZeroKMS, hence the same + // env gating as the rest of the suite. Assert range FILTERING only — + // ORDER BY on the encrypted column is unsupported on Supabase (no + // operator families). + it('filters an integer_ord column by range (gte/lte)', async () => { + const es = await makeInstance() + + const { data: insertedData, error: insertError } = await es + .from<typeof table, ProtectCiV3Row>('protect-ci-v3', table) + .insert([ + { age: 10, test_run_id: TEST_RUN_ID }, + { age: 25, test_run_id: TEST_RUN_ID }, + { age: 90, test_run_id: TEST_RUN_ID }, + ]) + .select('id') + + if (insertError) throw new Error(`[protect]: ${insertError.message}`) + insertedIds.push(...insertedData!.map((d) => d.id)) + + const { data, error } = await es + .from<typeof table, ProtectCiV3Row>('protect-ci-v3', table) + .select('id, age') + .gte('age', 20) + .lte('age', 30) + .eq('test_run_id', TEST_RUN_ID) + + if (error) throw new Error(`[protect]: ${error.message}`) + expect(data).toHaveLength(1) + expect(data![0].age).toBe(25) + }, 30000) + + it('filters a timestamp_ord column by range with Date values', async () => { + const es = await makeInstance() + + const { data: insertedData, error: insertError } = await es + .from<typeof table, ProtectCiV3Row>('protect-ci-v3', table) + .insert([ + { + registeredAt: new Date('2026-01-15T00:00:00.000Z'), + test_run_id: TEST_RUN_ID, + }, + { + registeredAt: new Date('2026-06-15T00:00:00.000Z'), + test_run_id: TEST_RUN_ID, + }, + ]) + .select('id') + + if (insertError) throw new Error(`[protect]: ${insertError.message}`) + insertedIds.push(...insertedData!.map((d) => d.id)) + + const { data, error } = await es + .from<typeof table, ProtectCiV3Row>('protect-ci-v3', table) + .select('id, registeredAt') + .gte('registeredAt', new Date('2026-05-01T00:00:00.000Z')) + .eq('test_run_id', TEST_RUN_ID) + + if (error) throw new Error(`[protect]: ${error.message}`) + expect(data).toHaveLength(1) + expect(data![0].registeredAt).toBeInstanceOf(Date) + expect(data![0].registeredAt.toISOString()).toBe( + '2026-06-15T00:00:00.000Z', + ) + }, 30000) + }, +) diff --git a/packages/stack/__tests__/supabase.test.ts b/packages/stack/__tests__/supabase.test.ts index 5a25ec3e..175c9060 100644 --- a/packages/stack/__tests__/supabase.test.ts +++ b/packages/stack/__tests__/supabase.test.ts @@ -24,7 +24,10 @@ const supabase = SUPABASE_ENABLED const table = encryptedTable('protect-ci', { encrypted: encryptedColumn('encrypted').freeTextSearch().equality(), age: encryptedColumn('age').dataType('number').equality(), - score: encryptedColumn('score').dataType('number').equality(), + // orderAndRange backs the encrypted range test below — the "range filtering + // works on Supabase" claim needs a CI-covered v2 baseline, not just the + // one-off live spike (see the v3 suite's matching range test). + score: encryptedColumn('score').dataType('number').equality().orderAndRange(), }) // Row type for the protect-ci table @@ -282,5 +285,51 @@ describe.skipIf(!SUPABASE_ENABLED)( expect(data).toHaveLength(1) expect(data![0].age).toBe(testAge) }, 30000) + + // Encrypted RANGE filtering on Supabase previously had no CI coverage — + // the custom ORE operator's resolution over PostgREST rested on a one-off + // live spike. This is the v2 baseline the v3 suite's range test mirrors. + // Range needs real ORE terms (live ZeroKMS), same gating as the suite. + // Note: range FILTERING only — ORDER BY on an encrypted column is + // unsupported on Supabase (operator families need superuser). + it('should filter encrypted number data with a range (gte/lte)', async () => { + const protectClient = await Encryption({ schemas: [table] }) + const eSupabase = encryptedSupabase({ + encryptionClient: protectClient, + supabaseClient: supabase, + }) + + const models = [ + { score: 10, otherField: 'low' }, + { score: 25, otherField: 'mid' }, + { score: 90, otherField: 'high' }, + ] + + const { data: insertedData, error: insertError } = await eSupabase + .from<ProtectCiRow>('protect-ci', table) + .insert(models.map((m) => ({ ...m, test_run_id: TEST_RUN_ID }))) + .select('id') + + if (insertError) { + throw new Error(`[protect]: ${insertError.message}`) + } + + insertedIds.push(...insertedData!.map((d) => d.id)) + + const { data, error } = await eSupabase + .from<ProtectCiRow>('protect-ci', table) + .select('id, score, otherField') + .gte('score', 20) + .lte('score', 30) + .eq('test_run_id', TEST_RUN_ID) + + if (error) { + throw new Error(`[protect]: ${error.message}`) + } + + expect(data).toHaveLength(1) + expect(data![0].score).toBe(25) + expect(data![0].otherField).toBe('mid') + }, 30000) }, ) diff --git a/packages/stack/__tests__/typed-client-v3.test-d.ts b/packages/stack/__tests__/typed-client-v3.test-d.ts new file mode 100644 index 00000000..03b929c9 --- /dev/null +++ b/packages/stack/__tests__/typed-client-v3.test-d.ts @@ -0,0 +1,173 @@ +import { describe, expectTypeOf, it } from 'vitest' +import type { EncryptionClient } from '@/encryption' +// Everything comes from the single `@cipherstash/stack/v3` surface (re-exported +// from src/encryption/v3.ts), exercising the re-export at the same time. +import { + encryptedTable, + typedClient, + types, + type V3DecryptedModel, + type V3EncryptedModel, +} from '@/encryption/v3' +import type { Encrypted } from '@/types' + +// A v3 table mixing every relevant capability tier: +const users = encryptedTable('users', { + email: types.TextEq('email'), // equality only + bio: types.TextSearch('bio'), // equality + order + free-text + note: types.Text('note'), // storage only (not queryable) + createdAt: types.TimestampOrd('created_at'), // equality + order +}) + +// A second registered table whose `weight` domain (integer_ord) is NOT present in +// `users`, so borrowing it is a genuine cross-table type error. +const other = encryptedTable('other', { + weight: types.IntegerOrd('weight'), +}) + +const client = typedClient({} as EncryptionClient, users, other) + +describe('typed v3 client — encrypt plaintext is pinned to the column domain', () => { + it('accepts the matching plaintext type per domain', () => { + expectTypeOf(client.encrypt).toBeCallableWith('alice@example.com', { + table: users, + column: users.email, + }) + expectTypeOf(client.encrypt).toBeCallableWith(new Date(), { + table: users, + column: users.createdAt, + }) + }) + + it('rejects a wrong-typed plaintext', () => { + client.encrypt( + // @ts-expect-error - number is not valid plaintext for a text column + 123, + { table: users, column: users.email }, + ) + }) +}) + +describe('typed v3 client — encryptQuery constrains queryType to capabilities', () => { + it('accepts capability-matched query types', () => { + expectTypeOf(client.encryptQuery).toBeCallableWith('alice@example.com', { + table: users, + column: users.email, + queryType: 'equality', + }) + expectTypeOf(client.encryptQuery).toBeCallableWith(new Date(), { + table: users, + column: users.createdAt, + queryType: 'orderAndRange', + }) + // text_search supports all three + expectTypeOf(client.encryptQuery).toBeCallableWith('needle', { + table: users, + column: users.bio, + queryType: 'freeTextSearch', + }) + }) + + it('rejects a query type the column does not support', () => { + client.encryptQuery('alice@example.com', { + table: users, + column: users.email, // equality only + // @ts-expect-error - text_eq column does not support 'orderAndRange' + queryType: 'orderAndRange', + }) + client.encryptQuery(new Date(), { + table: users, + column: users.createdAt, // equality + order, no free-text + // @ts-expect-error - timestamp_ord column does not support 'freeTextSearch' + queryType: 'freeTextSearch', + }) + }) + + it('rejects a storage-only column on the query path', () => { + client.encryptQuery('x', { + table: users, + // @ts-expect-error - storage-only text column is not queryable + column: users.note, + }) + }) +}) + +describe('typed v3 client — model encrypt validates schema fields', () => { + it('accepts a model whose schema fields match and allows passthrough fields', () => { + expectTypeOf(client.encryptModel).toBeCallableWith( + { id: 'u1', email: 'a@b.com', createdAt: new Date() }, + users, + ) + }) + + it('rejects a wrong-typed schema field', () => { + client.encryptModel( + { + id: 'u1', + // @ts-expect-error - email expects string, got number + email: 123, + }, + users, + ) + }) + + it('maps schema columns to Encrypted and preserves passthrough + nullability', () => { + // Passthrough `id` stays string; schema `email` becomes Encrypted. + expectTypeOf< + V3EncryptedModel<typeof users, { id: string; email: string }> + >().toEqualTypeOf<{ id: string; email: Encrypted }>() + + // Nullable schema field → Encrypted | null. + expectTypeOf< + V3EncryptedModel<typeof users, { id: string; email: string | null }> + >().toEqualTypeOf<{ id: string; email: Encrypted | null }>() + }) +}) + +describe('typed v3 client — model decrypt yields precise plaintext', () => { + it('reconstructs schema columns to their plaintext type regardless of the input field type', () => { + // Input is the encrypted row; output pins each schema column to its plaintext + // type (Date for timestamp, string for text). + expectTypeOf< + V3DecryptedModel< + typeof users, + { id: string; email: Encrypted; createdAt: Encrypted } + > + >().toEqualTypeOf<{ + id: string + email: string + createdAt: Date + }>() + }) + + it('decryptModel is callable with an encrypted row and the table', () => { + expectTypeOf(client.decryptModel).toBeCallableWith( + { id: 'u1', email: {} as Encrypted }, + users, + ) + }) +}) + +describe('typed v3 client — soundness', () => { + it('rejects a hand-rolled structural table (no brand / private field)', () => { + const fakeTable = { + tableName: 'users', + build: () => ({ tableName: 'users', columns: {} }), + } + client.encrypt('x', { + // @ts-expect-error - a structural object is not a registered branded v3 table + table: fakeTable, + column: users.email, + }) + }) + + it('rejects a column whose domain is not present in the table', () => { + // Plaintext is a string (valid for every `users` column domain) so the only + // error is the column itself failing the `ColumnsOf<typeof users>` constraint. + client.encrypt('x', { + table: users, + // @ts-expect-error - integer_ord column from `other` is not in ColumnsOf<typeof users> + column: other.weight, + }) + }) +}) diff --git a/packages/stack/__tests__/typed-client-v3.test.ts b/packages/stack/__tests__/typed-client-v3.test.ts new file mode 100644 index 00000000..c605cdec --- /dev/null +++ b/packages/stack/__tests__/typed-client-v3.test.ts @@ -0,0 +1,89 @@ +import { describe, expect, it } from 'vitest' +import type { EncryptionClient } from '@/encryption' +import { encryptedTable, typedClient, types } from '@/encryption/v3' + +const table = encryptedTable('t', { + when: types.Timestamp('when'), + note: types.Text('note'), + // camelCase JS property → snake_case DB name: reconstruction must key by the + // JS property (how the decrypted row is keyed), not the DB column name. + createdOn: types.Date('created_on'), +}) + +/** + * A minimal client stub whose model-decrypt methods resolve to a fixed + * `Result` payload. `typedClient` only `await`s these, so a plain Promise is a + * sufficient thenable. + */ +function fakeClient(data: Record<string, unknown>): EncryptionClient { + return { + decryptModel: () => Promise.resolve({ data }), + bulkDecryptModels: () => Promise.resolve({ data: [data] }), + } as unknown as EncryptionClient +} + +describe('typedClient — decrypt reconstruction', () => { + it('reconstructs Date columns from cast_as', async () => { + const client = typedClient( + fakeClient({ + when: '2020-01-02T03:04:05.000Z', + note: 'hi', + createdOn: '2026-07-01T00:00:00.000Z', + }), + table, + ) + + const result = await client.decryptModel({}, table) + expect(result.failure).toBeFalsy() + if (result.failure) return + + const data = result.data as Record<string, unknown> + expect(data.when).toBeInstanceOf(Date) + expect((data.when as Date).toISOString()).toBe('2020-01-02T03:04:05.000Z') + // Reconstructed by JS property (`createdOn`), though the DB column is + // `created_on` — a regression here would leave it an unparsed string. + expect(data.createdOn).toBeInstanceOf(Date) + expect((data.createdOn as Date).toISOString()).toBe( + '2026-07-01T00:00:00.000Z', + ) + expect(data.note).toBe('hi') // string column untouched + }) + + it('leaves null column values untouched', async () => { + const client = typedClient(fakeClient({ when: null, note: null }), table) + + const result = await client.decryptModel({}, table) + if (result.failure) return + + const data = result.data as Record<string, unknown> + expect(data.when).toBeNull() + expect(data.note).toBeNull() + }) + + it('reconstructs each row for bulkDecryptModels', async () => { + const client = typedClient( + fakeClient({ when: '2021-06-01T00:00:00.000Z', note: 'x' }), + table, + ) + + const result = await client.bulkDecryptModels([{}], table) + if (result.failure) return + + const rows = result.data as Array<Record<string, unknown>> + expect(rows).toHaveLength(1) + expect(rows[0].when).toBeInstanceOf(Date) + }) + + it('propagates a failure result unchanged', async () => { + const failing = { + decryptModel: () => + Promise.resolve({ + failure: { type: 'DecryptionError', message: 'boom' }, + }), + } as unknown as EncryptionClient + + const client = typedClient(failing, table) + const result = await client.decryptModel({}, table) + expect(result.failure).toBeTruthy() + }) +}) diff --git a/packages/stack/__tests__/types-public-surface.test-d.ts b/packages/stack/__tests__/types-public-surface.test-d.ts new file mode 100644 index 00000000..7bd45890 --- /dev/null +++ b/packages/stack/__tests__/types-public-surface.test-d.ts @@ -0,0 +1,42 @@ +import { describe, expectTypeOf, it } from 'vitest' +// Regression guard for the public `@cipherstash/stack/types` entrypoint +// (src/types-public.ts). The structural builder contracts and the +// `encryptModel` / `bulkEncryptModels` return-type mapper appear in PUBLIC +// return positions (encryption/index.ts), so consumers must be able to NAME +// them from the public path. Importing a member that is not re-exported fails +// typecheck — so this file compiling green proves the surface is complete. +import type { + BuildableColumn, + BuildableQueryColumn, + BuildableTable, + BuildableTableColumns, + BuildableV3QueryableColumn, + Encrypted, + EncryptedFromBuildableTable, +} from '@/types-public' + +describe('public @cipherstash/stack/types surface', () => { + it('exposes the structural builder contracts', () => { + // A v3 queryable column IS a BuildableColumn (interface extension). + expectTypeOf<BuildableV3QueryableColumn>().toMatchTypeOf<BuildableColumn>() + // The query-column union is nameable and non-trivial. + expectTypeOf<BuildableQueryColumn>().not.toBeNever() + // The client table contract is nameable. + expectTypeOf<BuildableTable['tableName']>().toBeString() + }) + + it('exposes EncryptedFromBuildableTable (the encryptModel return mapper)', () => { + interface Users extends BuildableTable { + readonly _columnType: { email: unknown } + } + type Row = { id: number; email: string } + type Enc = EncryptedFromBuildableTable<Row, Users> + + // Schema-column fields become Encrypted; passthrough fields keep their type. + expectTypeOf<Enc['email']>().toEqualTypeOf<Encrypted>() + expectTypeOf<Enc['id']>().toEqualTypeOf<number>() + + // The column-map helper is nameable too. + expectTypeOf<keyof BuildableTableColumns<Users>>().toEqualTypeOf<'email'>() + }) +}) diff --git a/packages/stack/__tests__/v3-matrix/catalog.ts b/packages/stack/__tests__/v3-matrix/catalog.ts new file mode 100644 index 00000000..994d9a22 --- /dev/null +++ b/packages/stack/__tests__/v3-matrix/catalog.ts @@ -0,0 +1,255 @@ +/** + * Type-driven v3 test matrix — single source of truth. + * + * The TypeScript analog of the Rust `eql_v3` `scalar_matrix!` harness + * (`encrypt-query-language/tests/sqlx`): one declarative catalog drives both a + * runtime `it.each` matrix (`matrix.test.ts`) and type-level assertions + * (`matrix.test-d.ts`), instead of hand-rolling per-domain test bodies. + * + * COVERAGE IS MANDATORY. The catalog is `satisfies Record<EqlV3TypeName, + * DomainSpec>`, and `EqlV3TypeName` is derived from the real column union + * (`AnyEncryptedV3Column`). Add a domain to the SDK and this file fails to + * compile until it has a row — the compile-time analog of, and stronger than, + * the Rust `test:matrix:inventory` cross-check (it names each missing domain). + * + * Every field here is consumed by a test: `builder`/`ColumnClass` by the + * instanceof check, `castAs` + `indexes` by the `build()` `toStrictEqual`, and + * `capabilities` by `getQueryCapabilities()`/`isQueryable()`. + */ + +import type { + AnyEncryptedV3Column, + EqlTypeForColumn, + QueryCapabilities, +} from '@/eql/v3' +import { + EncryptedBooleanColumn, + EncryptedDateColumn, + EncryptedDateEqColumn, + EncryptedDateOrdColumn, + EncryptedDateOrdOreColumn, + EncryptedRealColumn, + EncryptedRealEqColumn, + EncryptedRealOrdColumn, + EncryptedRealOrdOreColumn, + EncryptedDoubleColumn, + EncryptedDoubleEqColumn, + EncryptedDoubleOrdColumn, + EncryptedDoubleOrdOreColumn, + EncryptedSmallintColumn, + EncryptedSmallintEqColumn, + EncryptedSmallintOrdColumn, + EncryptedSmallintOrdOreColumn, + EncryptedIntegerColumn, + EncryptedIntegerEqColumn, + EncryptedIntegerOrdColumn, + EncryptedIntegerOrdOreColumn, + EncryptedNumericColumn, + EncryptedNumericEqColumn, + EncryptedNumericOrdColumn, + EncryptedNumericOrdOreColumn, + EncryptedTextColumn, + EncryptedTextEqColumn, + EncryptedTextMatchColumn, + EncryptedTextOrdColumn, + EncryptedTextOrdOreColumn, + EncryptedTextSearchColumn, + EncryptedTimestampColumn, + EncryptedTimestampEqColumn, + EncryptedTimestampOrdColumn, + EncryptedTimestampOrdOreColumn, + types, +} from '@/eql/v3' +import type { ColumnSchema } from '@/schema' + +/** + * The canonical union of every v3 domain name — derived STRAIGHT from the real + * column union (`AnyEncryptedV3Column`) via the exported `EqlTypeForColumn` + * helper, not hand-copied. This is the key set the `Record` below must cover. + */ +export type EqlV3TypeName = EqlTypeForColumn<AnyEncryptedV3Column> + +/** One row of the type-driven matrix: everything a test needs about a domain. */ +export type DomainSpec = Readonly<{ + /** Column builder under test. */ + builder: (name: string) => AnyEncryptedV3Column + /** Concrete class the builder must instantiate (`toBeInstanceOf`). */ + ColumnClass: new ( + ...args: never[] + ) => AnyEncryptedV3Column + /** Plaintext axis emitted by `build().cast_as`. */ + castAs: ColumnSchema['cast_as'] + /** Semantic capability flags (`getQueryCapabilities()`). */ + capabilities: QueryCapabilities + /** + * The full `build().indexes` output — stored as DATA per row (like the Rust + * harness) rather than derived from `capabilities`, because `text_search` + * overrides `build()` to emit `unique + ore + match` where the capability → + * index rule would omit `unique` for an order-capable column. + */ + indexes: ColumnSchema['indexes'] + /** + * Representative + edge plaintext values that MUST round-trip through live + * encrypt/decrypt (consumed by `matrix-live.test.ts`). Typed as the loose + * plaintext union rather than per-row: the precise `castAs → plaintext` axis + * is already proven at the type level in `matrix.test-d.ts` (`InferPlaintext`), + * and a per-row generic would break the single `satisfies Record<…>` that is + * this file's coverage mechanism. Numeric samples are split integer-vs- + * fractional: `build()` emits `cast_as:'number'` uniformly so the FFI can't + * tell `integer` from `double`, and a fractional value on an int-named domain is + * untested territory (it would truncate against a real narrow PG column). + */ + samples: ReadonlyArray<string | number | boolean | Date> + /** + * Values that MUST fail encryption. Number domains reject `NaN`/`±Infinity` + * via a global guard; other domains omit this. + */ + errorSamples?: ReadonlyArray<number> +}> + +/** + * `Object.entries` that preserves the literal key union instead of widening to + * `string` — so `eqlType` in the runtime matrix stays `EqlV3TypeName`. + */ +export function typedEntries<K extends string, V>( + obj: Record<K, V>, +): Array<[K, V]> { + return Object.entries(obj) as Array<[K, V]> +} + +// Capability shorthands (mirror the SDK's internal presets). +const STORAGE = { + equality: false, + orderAndRange: false, + freeTextSearch: false, +} as const +const EQ = { + equality: true, + orderAndRange: false, + freeTextSearch: false, +} as const +const ORD = { + equality: true, + orderAndRange: true, + freeTextSearch: false, +} as const +const MATCH_ONLY = { + equality: false, + orderAndRange: false, + freeTextSearch: true, +} as const +const FULL = { + equality: true, + orderAndRange: true, + freeTextSearch: true, +} as const + +// Index shorthands (mirror `build().indexes`). Type-annotated rather than +// `as const`: annotation contextually types the literals so enum fields like +// `kind: 'ngram'` stay checked against the schema while arrays remain MUTABLE +// — `ColumnSchema['indexes']` rejects the `readonly` arrays `as const` produces. +type Indexes = ColumnSchema['indexes'] +const NONE: Indexes = {} +const UNIQUE_IDX: Indexes = { unique: { token_filters: [] } } +const ORE_IDX: Indexes = { ore: {} } +// Text order domains (`text_ord`, `text_ord_ore`) carry BOTH `hm` (unique) and +// `ob` (ore): their eql_v3 SQL domains require `hm` because text equality is +// HMAC-based, unlike numeric/date order domains which answer equality via `ob`. +const TEXT_ORD_IDX: Indexes = { unique: { token_filters: [] }, ore: {} } +const MATCH_BLOCK: NonNullable<Indexes>['match'] = { + tokenizer: { kind: 'ngram', token_length: 3 }, + token_filters: [{ kind: 'downcase' }], + k: 6, + m: 2048, + include_original: true, +} +const MATCH_IDX: Indexes = { match: MATCH_BLOCK } +const TEXT_SEARCH_IDX: Indexes = { + unique: { token_filters: [] }, + ore: {}, + match: MATCH_BLOCK, +} + +// Sample plaintexts per plaintext axis, consumed by `matrix-live.test.ts`. +// Numeric sets are split by domain width: integers (incl. type bounds) for +// smallint/integer, fractionals for real/double/numeric. See `DomainSpec.samples`. +const SMALLINT_S = [0, -1, 32767, -32768] as const +const INTEGER_S = [0, -42, 2147483647, -2147483648] as const +const REAL_S = [0, 77.5, -117.25, 0.5] as const +const DOUBLE_S = [0, -117.123456, 1e15, -1e15] as const +const NUMERIC_S = [0, 12345.678, -42, -0.5] as const +const TEXT_S = ['', 'ada@example.com', 'Ada Lovelace'] as const +// Samples for the ob-carrying text domains (text_ord, text_ord_ore, +// text_search). These CANNOT include '' like TEXT_S: their eql_v3 SQL domain +// CHECKs demand a non-empty ore term (`jsonb_array_length(VALUE->'ob') > 0`), +// and the ORE term of the empty string has zero blocks — storing '' in one of +// these domains is rejected by Postgres with a check-constraint violation +// (observed live: matrix-live-pg's seed INSERT failed `text_ord_ore_check`). +// The '' edge stays covered where it IS storable: text, text_eq, text_match. +// Row-A/row-B constraints preserved: samples[0] ≠ samples[1] (ord equality +// proof selects row A only), and the match proof's 'ada' substring occurs in +// samples[1] only (text_search match proof targets row B). +const TEXT_ORD_S = [ + 'grace@example.net', + 'ada@example.com', + 'Ada Lovelace', +] as const +const BOOLEAN_S = [true, false] as const +const DATE_S = [ + new Date('2026-07-01T00:00:00.000Z'), + new Date('1970-01-01T00:00:00.000Z'), +] as const +// Every number domain rejects these via the global encrypt guard. +const NUM_ERR = [ + Number.NaN, + Number.POSITIVE_INFINITY, + Number.NEGATIVE_INFINITY, +] as const + +// biome-ignore format: one row per domain reads as a table; keep it dense. +export const V3_MATRIX = { + // integer + 'eql_v3.integer': { builder: types.Integer, ColumnClass: EncryptedIntegerColumn, castAs: 'number', capabilities: STORAGE, indexes: NONE, samples: INTEGER_S, errorSamples: NUM_ERR }, + 'eql_v3.integer_eq': { builder: types.IntegerEq, ColumnClass: EncryptedIntegerEqColumn, castAs: 'number', capabilities: EQ, indexes: UNIQUE_IDX, samples: INTEGER_S, errorSamples: NUM_ERR }, + 'eql_v3.integer_ord_ore': { builder: types.IntegerOrdOre, ColumnClass: EncryptedIntegerOrdOreColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: INTEGER_S, errorSamples: NUM_ERR }, + 'eql_v3.integer_ord': { builder: types.IntegerOrd, ColumnClass: EncryptedIntegerOrdColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: INTEGER_S, errorSamples: NUM_ERR }, + // smallint + 'eql_v3.smallint': { builder: types.Smallint, ColumnClass: EncryptedSmallintColumn, castAs: 'number', capabilities: STORAGE, indexes: NONE, samples: SMALLINT_S, errorSamples: NUM_ERR }, + 'eql_v3.smallint_eq': { builder: types.SmallintEq, ColumnClass: EncryptedSmallintEqColumn, castAs: 'number', capabilities: EQ, indexes: UNIQUE_IDX, samples: SMALLINT_S, errorSamples: NUM_ERR }, + 'eql_v3.smallint_ord_ore': { builder: types.SmallintOrdOre, ColumnClass: EncryptedSmallintOrdOreColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: SMALLINT_S, errorSamples: NUM_ERR }, + 'eql_v3.smallint_ord': { builder: types.SmallintOrd, ColumnClass: EncryptedSmallintOrdColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: SMALLINT_S, errorSamples: NUM_ERR }, + // date + 'eql_v3.date': { builder: types.Date, ColumnClass: EncryptedDateColumn, castAs: 'date', capabilities: STORAGE, indexes: NONE, samples: DATE_S }, + 'eql_v3.date_eq': { builder: types.DateEq, ColumnClass: EncryptedDateEqColumn, castAs: 'date', capabilities: EQ, indexes: UNIQUE_IDX, samples: DATE_S }, + 'eql_v3.date_ord_ore': { builder: types.DateOrdOre, ColumnClass: EncryptedDateOrdOreColumn, castAs: 'date', capabilities: ORD, indexes: ORE_IDX, samples: DATE_S }, + 'eql_v3.date_ord': { builder: types.DateOrd, ColumnClass: EncryptedDateOrdColumn, castAs: 'date', capabilities: ORD, indexes: ORE_IDX, samples: DATE_S }, + // timestamp + 'eql_v3.timestamp': { builder: types.Timestamp, ColumnClass: EncryptedTimestampColumn, castAs: 'timestamp', capabilities: STORAGE, indexes: NONE, samples: DATE_S }, + 'eql_v3.timestamp_eq': { builder: types.TimestampEq, ColumnClass: EncryptedTimestampEqColumn, castAs: 'timestamp', capabilities: EQ, indexes: UNIQUE_IDX, samples: DATE_S }, + 'eql_v3.timestamp_ord_ore': { builder: types.TimestampOrdOre, ColumnClass: EncryptedTimestampOrdOreColumn, castAs: 'timestamp', capabilities: ORD, indexes: ORE_IDX, samples: DATE_S }, + 'eql_v3.timestamp_ord': { builder: types.TimestampOrd, ColumnClass: EncryptedTimestampOrdColumn, castAs: 'timestamp', capabilities: ORD, indexes: ORE_IDX, samples: DATE_S }, + // numeric + 'eql_v3.numeric': { builder: types.Numeric, ColumnClass: EncryptedNumericColumn, castAs: 'number', capabilities: STORAGE, indexes: NONE, samples: NUMERIC_S, errorSamples: NUM_ERR }, + 'eql_v3.numeric_eq': { builder: types.NumericEq, ColumnClass: EncryptedNumericEqColumn, castAs: 'number', capabilities: EQ, indexes: UNIQUE_IDX, samples: NUMERIC_S, errorSamples: NUM_ERR }, + 'eql_v3.numeric_ord_ore': { builder: types.NumericOrdOre, ColumnClass: EncryptedNumericOrdOreColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: NUMERIC_S, errorSamples: NUM_ERR }, + 'eql_v3.numeric_ord': { builder: types.NumericOrd, ColumnClass: EncryptedNumericOrdColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: NUMERIC_S, errorSamples: NUM_ERR }, + // text + 'eql_v3.text': { builder: types.Text, ColumnClass: EncryptedTextColumn, castAs: 'string', capabilities: STORAGE, indexes: NONE, samples: TEXT_S }, + 'eql_v3.text_eq': { builder: types.TextEq, ColumnClass: EncryptedTextEqColumn, castAs: 'string', capabilities: EQ, indexes: UNIQUE_IDX, samples: TEXT_S }, + 'eql_v3.text_match': { builder: types.TextMatch, ColumnClass: EncryptedTextMatchColumn, castAs: 'string', capabilities: MATCH_ONLY, indexes: MATCH_IDX, samples: TEXT_S }, + 'eql_v3.text_ord_ore': { builder: types.TextOrdOre, ColumnClass: EncryptedTextOrdOreColumn, castAs: 'string', capabilities: ORD, indexes: TEXT_ORD_IDX, samples: TEXT_ORD_S }, + 'eql_v3.text_ord': { builder: types.TextOrd, ColumnClass: EncryptedTextOrdColumn, castAs: 'string', capabilities: ORD, indexes: TEXT_ORD_IDX, samples: TEXT_ORD_S }, + 'eql_v3.text_search': { builder: types.TextSearch, ColumnClass: EncryptedTextSearchColumn, castAs: 'string', capabilities: FULL, indexes: TEXT_SEARCH_IDX, samples: TEXT_ORD_S }, + // boolean + 'eql_v3.boolean': { builder: types.Boolean, ColumnClass: EncryptedBooleanColumn, castAs: 'boolean', capabilities: STORAGE, indexes: NONE, samples: BOOLEAN_S }, + // real + 'eql_v3.real': { builder: types.Real, ColumnClass: EncryptedRealColumn, castAs: 'number', capabilities: STORAGE, indexes: NONE, samples: REAL_S, errorSamples: NUM_ERR }, + 'eql_v3.real_eq': { builder: types.RealEq, ColumnClass: EncryptedRealEqColumn, castAs: 'number', capabilities: EQ, indexes: UNIQUE_IDX, samples: REAL_S, errorSamples: NUM_ERR }, + 'eql_v3.real_ord_ore': { builder: types.RealOrdOre, ColumnClass: EncryptedRealOrdOreColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: REAL_S, errorSamples: NUM_ERR }, + 'eql_v3.real_ord': { builder: types.RealOrd, ColumnClass: EncryptedRealOrdColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: REAL_S, errorSamples: NUM_ERR }, + // double + 'eql_v3.double': { builder: types.Double, ColumnClass: EncryptedDoubleColumn, castAs: 'number', capabilities: STORAGE, indexes: NONE, samples: DOUBLE_S, errorSamples: NUM_ERR }, + 'eql_v3.double_eq': { builder: types.DoubleEq, ColumnClass: EncryptedDoubleEqColumn, castAs: 'number', capabilities: EQ, indexes: UNIQUE_IDX, samples: DOUBLE_S, errorSamples: NUM_ERR }, + 'eql_v3.double_ord_ore': { builder: types.DoubleOrdOre, ColumnClass: EncryptedDoubleOrdOreColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: DOUBLE_S, errorSamples: NUM_ERR }, + 'eql_v3.double_ord': { builder: types.DoubleOrd, ColumnClass: EncryptedDoubleOrdColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: DOUBLE_S, errorSamples: NUM_ERR }, +} as const satisfies Record<EqlV3TypeName, DomainSpec> diff --git a/packages/stack/__tests__/v3-matrix/matrix-audit.test-d.ts b/packages/stack/__tests__/v3-matrix/matrix-audit.test-d.ts new file mode 100644 index 00000000..cdaa95db --- /dev/null +++ b/packages/stack/__tests__/v3-matrix/matrix-audit.test-d.ts @@ -0,0 +1,31 @@ +/** + * Type-level pin of a real v3 asymmetry: audit metadata is available on the + * encrypt-side operations (which are chainable) but NOT on `decryptModel` / + * `bulkDecryptModels`, which return a bare `Promise<Result<…>>` rather than a + * chainable operation. Documented here as an executable invariant so the gap + * (v2's `decryptModel().audit(...)` has no v3 equivalent) can't silently change. + * + * Runs via `pnpm test:types`. + */ +import { describe, expectTypeOf, it } from 'vitest' +import type { EncryptionClient } from '@/encryption' +import { encryptedTable, typedClient, types } from '@/encryption/v3' + +const users = encryptedTable('u', { email: types.TextEq('email') }) +declare const client: EncryptionClient +const typed = typedClient(client, users) + +describe('v3 typed client audit/lock-context chainability (types)', () => { + it('exposes .audit() and .withLockContext() on the encrypt operation', () => { + const op = typed.encrypt('x', { table: users, column: users.email }) + expectTypeOf(op).toHaveProperty('audit') + expectTypeOf(op).toHaveProperty('withLockContext') + }) + + it('does NOT expose .audit()/.withLockContext() on decryptModel (bare Promise)', () => { + const result = typed.decryptModel({ email: {} as never }, users) + // A Promise, not a chainable operation — no audit/lock-context hook. + expectTypeOf(result).not.toHaveProperty('audit') + expectTypeOf(result).not.toHaveProperty('withLockContext') + }) +}) diff --git a/packages/stack/__tests__/v3-matrix/matrix-bulk.test.ts b/packages/stack/__tests__/v3-matrix/matrix-bulk.test.ts new file mode 100644 index 00000000..61915f15 --- /dev/null +++ b/packages/stack/__tests__/v3-matrix/matrix-bulk.test.ts @@ -0,0 +1,47 @@ +/** + * Bulk-at-scale proof for the v3 typed client (mirrors v2 `bulk-protect.test.ts`). + * The only pre-existing v3 bulk test ran against a hand-written stub; this one + * round-trips 100 models through the v3 typed client's `bulkEncryptModels` / + * `bulkDecryptModels` against real FFI, exercising v3 model reconstruction at + * scale. Live soft-skip. + */ +import 'dotenv/config' +import { beforeAll, describe, expect, it } from 'vitest' +import { EncryptionV3, encryptedTable, types } from '@/encryption/v3' +import { unwrapResult } from '../fixtures' +import { describeLive, LIVE_CIPHERSTASH_ENABLED } from '../helpers/live-gate' + +const people = encryptedTable('v3_bulk_people', { + nickname: types.TextEq('nickname'), + age: types.IntegerOrd('age'), +}) + +describeLive('v3 typed client bulk-at-scale (live)', () => { + let client: Awaited<ReturnType<typeof EncryptionV3<[typeof people]>>> + + beforeAll(async () => { + client = await EncryptionV3({ schemas: [people] }) + }, 30000) + + it('round-trips 100 models through bulkEncryptModels/bulkDecryptModels', async () => { + const rows = Array.from({ length: 100 }, (_, i) => ({ + nickname: `user-${i}`, + age: i, + })) + + const encrypted = unwrapResult(await client.bulkEncryptModels(rows, people)) + expect(encrypted).toHaveLength(100) + // Guard: every model field is a real ciphertext, not a plaintext passthrough. + expect(encrypted[0].nickname).toHaveProperty('c') + expect(encrypted[0].age).toHaveProperty('c') + + const decrypted = unwrapResult( + await client.bulkDecryptModels(encrypted, people), + ) + expect(decrypted).toHaveLength(100) + for (let i = 0; i < 100; i++) { + expect(decrypted[i].nickname).toBe(`user-${i}`) + expect(decrypted[i].age).toBe(i) + } + }, 60000) +}) diff --git a/packages/stack/__tests__/v3-matrix/matrix-identity-live.test.ts b/packages/stack/__tests__/v3-matrix/matrix-identity-live.test.ts new file mode 100644 index 00000000..8f047706 --- /dev/null +++ b/packages/stack/__tests__/v3-matrix/matrix-identity-live.test.ts @@ -0,0 +1,65 @@ +/** + * Live identity-aware coverage for the v3 typed client: lock-context round-trips + * and audit metadata. Kept separate from `matrix-lock-context.test.ts` because + * that file mocks `@cipherstash/protect-ffi` file-wide — a mock would neutralize + * a "live" assertion. No mock here: these hit a real CipherStash workspace and + * soft-skip when credentials (and, for lock context, `USER_JWT`) are absent, + * mirroring the v2 `audit.test.ts` / lock-context pattern. + */ +import 'dotenv/config' +import { beforeAll, describe, expect, it } from 'vitest' +import { EncryptionV3, encryptedTable, types } from '@/encryption/v3' +import { LockContext } from '@/identity' +import { unwrapResult } from '../fixtures' +import { describeLive, LIVE_CIPHERSTASH_ENABLED } from '../helpers/live-gate' + +const users = encryptedTable('v3_identity_live_users', { + email: types.TextEq('email'), +}) + +describeLive('v3 typed client identity-aware operations (live)', () => { + let client: Awaited<ReturnType<typeof EncryptionV3<[typeof users]>>> + + beforeAll(async () => { + client = await EncryptionV3({ schemas: [users] }) + }, 30000) + + it('round-trips a model with a lock context (encrypt + decrypt bound to identity)', async () => { + const userJwt = process.env.USER_JWT + if (!userJwt) { + console.log('Skipping lock context test - no USER_JWT provided') + return + } + + const lc = new LockContext() + const lockContext = await lc.identify(userJwt) + if (lockContext.failure) { + throw new Error(`[protect]: ${lockContext.failure.message}`) + } + + const encrypted = unwrapResult( + await client + .encryptModel({ email: 'ada@example.com' }, users) + .withLockContext(lockContext.data), + ) + expect(encrypted.email).toHaveProperty('c') + + // decryptModel takes the lock context as a positional 3rd arg. + const decrypted = unwrapResult( + await client.decryptModel(encrypted, users, lockContext.data), + ) + expect(decrypted.email).toBe('ada@example.com') + }, 30000) + + it('accepts .audit({ metadata }) on the encrypt path and still round-trips', async () => { + const encrypted = unwrapResult( + await client + .encrypt('secret@example.com', { table: users, column: users.email }) + .audit({ metadata: { sub: 'toby@cipherstash.com', type: 'encrypt' } }), + ) + expect(encrypted).toHaveProperty('c') + + const decrypted = unwrapResult(await client.decrypt(encrypted)) + expect(decrypted).toBe('secret@example.com') + }, 30000) +}) diff --git a/packages/stack/__tests__/v3-matrix/matrix-keyset.test.ts b/packages/stack/__tests__/v3-matrix/matrix-keyset.test.ts new file mode 100644 index 00000000..cd6c2a77 --- /dev/null +++ b/packages/stack/__tests__/v3-matrix/matrix-keyset.test.ts @@ -0,0 +1,55 @@ +/** + * Keyset configuration for the v3 typed client (mirrors v2 `keysets.test.ts`). + * The invalid-UUID case is deterministic — validation happens before any network + * — so it runs in CI without credentials; the round-trip case is live soft-skip. + */ +import 'dotenv/config' +import { ensureKeyset } from '@cipherstash/protect-ffi' +import { beforeAll, describe, expect, it } from 'vitest' +import { EncryptionV3, encryptedTable, types } from '@/encryption/v3' +import { unwrapResult } from '../fixtures' +import { describeLive, LIVE_CIPHERSTASH_ENABLED } from '../helpers/live-gate' + +const users = encryptedTable('v3_keyset_users', { + email: types.TextEq('email'), +}) + +describe('EncryptionV3 keyset config (deterministic)', () => { + it('rejects an invalid keyset id before touching the network', async () => { + await expect( + EncryptionV3({ + schemas: [users], + config: { keyset: { id: 'invalid-uuid' } }, + }), + ).rejects.toThrow( + '[encryption]: Invalid UUID provided for keyset id. Must be a valid UUID.', + ) + }) +}) + +describeLive('EncryptionV3 keyset config (live)', () => { + let keysetId: string + + beforeAll(async () => { + const keyset = await ensureKeyset({ name: 'Test' }) + keysetId = keyset.id + }, 30000) + + it('round-trips a value using an explicit keyset id', async () => { + const client = await EncryptionV3({ + schemas: [users], + config: { keyset: { id: keysetId } }, + }) + + const encrypted = unwrapResult( + await client.encrypt('hello@example.com', { + table: users, + column: users.email, + }), + ) + expect(encrypted).toHaveProperty('c') + + const decrypted = unwrapResult(await client.decrypt(encrypted)) + expect(decrypted).toBe('hello@example.com') + }, 30000) +}) diff --git a/packages/stack/__tests__/v3-matrix/matrix-live-pg.test.ts b/packages/stack/__tests__/v3-matrix/matrix-live-pg.test.ts new file mode 100644 index 00000000..bd1343bf --- /dev/null +++ b/packages/stack/__tests__/v3-matrix/matrix-live-pg.test.ts @@ -0,0 +1,301 @@ +/** + * Live Postgres coverage for ALL 35 v3 domains — one query-correctness proof + * per domain, dispatched by capability tier, against a real installed eql_v3 + * extension. + * + * `matrix-live.test.ts` proves every domain round-trips through live FFI + * ciphertext, but never touches SQL. `schema-v3-pg.test.ts` proves real SQL + * query behaviour, but only for 4 hand-picked domains. Neither is redundant + * with this file: the equality-via-ORE fix (`infer-index-type.ts`) shows an + * SDK-side bug can hide behind a clean FFI round-trip and only surface + * against real Postgres — defence in depth means every domain gets that + * proof, not just a representative few. This file also doubles as one + * canonical, runnable example per capability tier of how to actually query + * each kind of v3 domain in SQL — useful reference for engineers and agents + * writing new domain-consuming code. + * + * ONE mega table (all 35 domains, one column each, like `matrix-live.test.ts`), + * two seeded rows (`samples[0]` / `samples[1]` from the catalog — every domain + * has at least two), one query per domain proving it selects the expected row + * and not the other. Dispatch mirrors the priority `resolveIndexType` itself + * uses (match > unique > ore > none): + * - match (text_match, text_search): `eql_v3.match_term` + `bloom_filter` + * - eq (*_eq domains): `eql_v3.eq_term` + `hmac_256` + * - ord (*_ord / *_ord_ore domains): `eql_v3.ord_term` + `ore_block_256`, + * queried with `queryType:'equality'` — the exact path Part A fixed. Most + * ord-tier domains (all but text) have no `eq_term` at all in the real + * `eql_v3` SQL (verified against the fixture), so this is not a stylistic + * choice: it is the only equality path that exists for them. + * - storage (no index): no query is possible; proves the ciphertext, cast to + * THIS SPECIFIC Postgres domain type, survives a real INSERT/SELECT and + * still decrypts — the one thing the FFI-only round-trip can't show. + */ +import 'dotenv/config' +import postgres from 'postgres' +import { afterAll, beforeAll, describe, expect, it } from 'vitest' +import { Encryption } from '@/encryption' +import { EncryptionV3, encryptedTable } from '@/encryption/v3' +import { unwrapResult } from '../fixtures' +import { assertV3WireEnvelope, installEqlV3IfNeeded } from '../helpers/eql-v3' +import { describeLivePg, LIVE_EQL_V3_PG_ENABLED } from '../helpers/live-gate' +import { + type DomainSpec, + type EqlV3TypeName, + typedEntries, + V3_MATRIX, +} from './catalog' + +// Previously force-skipped (CI run 28569708268, PR #540): `beforeAll` crashed +// with `PostgresError: invalid input syntax for type json` on the dynamic +// 35-column INSERT. Root cause was a postgres.js serialization gap — a bare +// ciphertext object stringified to `"[object Object]"` — now fixed by wrapping +// every INSERT param in `sql.json(...)` (see `beforeAll`; the fix landed right +// after the skip and the skip was simply left stale). Re-enabled here as an +// ordinary credential-gated suite: it runs in CI (which supplies DATABASE_URL + +// CS_* creds) and self-skips locally when they are absent. + +const databaseUrl = process.env.DATABASE_URL +const sql = LIVE_EQL_V3_PG_ENABLED + ? postgres(databaseUrl as string, { prepare: false }) + : (undefined as unknown as postgres.Sql) + +const TABLE_NAME = 'v3_matrix_live_pg' +const TEST_RUN_ID = `matrix-live-pg-${Date.now()}-${Math.random().toString(36).slice(2, 8)}` + +/** `eql_v3.integer_ord` -> `integer_ord`: a valid, unique Postgres column name. */ +const slug = (t: EqlV3TypeName): string => t.replace('eql_v3.', '') + +const domains = typedEntries(V3_MATRIX) + +const columns = Object.fromEntries( + domains.map(([t, spec]) => [slug(t), spec.builder(slug(t))]), +) +const table = encryptedTable(TABLE_NAME, columns as never) + +/** + * The one proof each domain's configured indexes call for — mirrors the + * priority `resolveIndexType`/`inferIndexType` themselves use: match wins over + * unique wins over ore. `text_search` carries all three but gets the match + * proof (its distinguishing, richest capability); the plain `*_eq` domains get + * the eq proof; every `*_ord`/`*_ord_ore` domain (including the text ones, + * which also have an `eq_term` but are queried the same way as their + * non-text siblings for consistency) gets the equality-via-ORE proof. + */ +type ProofKind = 'match' | 'eq' | 'ord' | 'storage' +function proofKindFor(indexes: DomainSpec['indexes']): ProofKind { + const idx = indexes ?? {} + if (idx.match) return 'match' + if (idx.unique) return 'eq' + if (idx.ore) return 'ord' + return 'storage' +} + +const matchDomains = domains.filter( + ([, spec]) => proofKindFor(spec.indexes) === 'match', +) +const eqDomains = domains.filter( + ([, spec]) => proofKindFor(spec.indexes) === 'eq', +) +const ordDomains = domains.filter( + ([, spec]) => proofKindFor(spec.indexes) === 'ord', +) +const storageDomains = domains.filter( + ([, spec]) => proofKindFor(spec.indexes) === 'storage', +) + +type Row = { id: number } + +let client: Awaited<ReturnType<typeof EncryptionV3>> +let termClient: Awaited<ReturnType<typeof Encryption>> +let idA: number +let idB: number +// Query terms, pre-encrypted once in `beforeAll` (not per `it.each` case). +const eqTerms: Record<string, unknown> = {} +const ordTerms: Record<string, unknown> = {} +const matchTerms: Record<string, unknown> = {} + +beforeAll(async () => { + if (!LIVE_EQL_V3_PG_ENABLED) return + + await installEqlV3IfNeeded(sql) + client = await EncryptionV3({ schemas: [table] as never }) + // INTERIM (CIP-3402): protect-ffi 0.27 has no v3 scalar query wire shape — + // scalar encryptQuery on the v3-wire client throws EQL_V3_QUERY_UNSUPPORTED. + // Query terms come from a second, explicitly v2-wire client: the + // eql_v3_internal extractors below read only the term keys from the jsonb, + // and index terms are identical across wire formats. + termClient = await Encryption({ + schemas: [table] as never, + config: { eqlVersion: 2 }, + }) + + const columnDefs = domains + .map(([t]) => `"${slug(t)}" ${t} NOT NULL`) + .join(',\n ') + + await sql.unsafe(` + CREATE TABLE IF NOT EXISTS ${TABLE_NAME} ( + id INTEGER PRIMARY KEY GENERATED ALWAYS AS IDENTITY, + test_run_id TEXT NOT NULL, + ${columnDefs} + ) + `) + + // Two model rows: row A carries samples[0], row B carries samples[1], for + // every domain — every catalog `samples` array has at least two entries. + const rowA: Record<string, unknown> = {} + const rowB: Record<string, unknown> = {} + for (const [t, spec] of domains) { + rowA[slug(t)] = spec.samples[0] + rowB[slug(t)] = spec.samples[1] + } + + const [encA, encB] = unwrapResult( + await client.bulkEncryptModels([rowA, rowB] as never, table as never), + ) as Array<Record<string, unknown>> + + // Generation handshake: fail loudly on client/bundle wire-format skew + // before the 35-column INSERT turns it into an opaque 23514. + for (const [name, value] of Object.entries(encA)) { + assertV3WireEnvelope(value, `matrix-live-pg seed column ${name}`) + } + + const colNames = domains.map(([t]) => `"${slug(t)}"`) + const insertRow = async (enc: Record<string, unknown>): Promise<number> => { + const casts = domains.map(([t], i) => `$${i + 2}::${t}`) + // `sql.json(...)` (not the bare ciphertext object): postgres.js only infers + // an explicit wire type for `Parameter`/`Date`/`Uint8Array`/boolean/bigint — + // a plain object falls through to `'' + x` (`Bind()` in + // postgres/src/connection.js), i.e. the literal string `"[object Object]"`, + // which Postgres rejects as invalid JSON before the domain cast ever runs. + const values = domains.map(([t]) => sql.json(enc[slug(t)] as never)) + const [row] = await sql.unsafe<Row[]>( + `INSERT INTO ${TABLE_NAME} (test_run_id, ${colNames.join(', ')}) + VALUES ($1, ${casts.join(', ')}) + RETURNING id`, + [TEST_RUN_ID, ...values], + ) + return row.id + } + idA = await insertRow(encA) + idB = await insertRow(encB) + + const columnRef = (t: EqlV3TypeName) => + (table as unknown as Record<string, unknown>)[slug(t)] as never + + // The full `opts` object (not just `column`) is cast `as never`: `encryptQuery` + // derives its allowed `queryType` union FROM the column's type + // (`QueryTypesForColumn<C>`), so a `never`-typed `column` alone collapses + // `queryType` to `undefined` rather than widening it — this table's columns + // are built dynamically (`Object.fromEntries`), so none of them carry a + // statically-known type for `encryptQuery` to key off in the first place. + for (const [t, spec] of eqDomains) { + eqTerms[slug(t)] = unwrapResult( + await termClient.encryptQuery( + spec.samples[0] as never, + { + table, + column: columnRef(t), + queryType: 'equality', + } as never, + ), + ) + } + for (const [t, spec] of ordDomains) { + ordTerms[slug(t)] = unwrapResult( + await termClient.encryptQuery( + spec.samples[0] as never, + { + table, + column: columnRef(t), + queryType: 'equality', + } as never, + ), + ) + } + // text_match/text_search: query a substring of row B's sample. Row A's + // shared `TEXT_S[0]` is `''` — a degenerate containment target — so the + // match proof targets row B instead of the usual row A. + for (const [t] of matchDomains) { + matchTerms[slug(t)] = unwrapResult( + await termClient.encryptQuery( + 'ada' as never, + { + table, + column: columnRef(t), + queryType: 'freeTextSearch', + } as never, + ), + ) + } +}, 120000) + +afterAll(async () => { + if (!LIVE_EQL_V3_PG_ENABLED) return + await sql.unsafe(`DELETE FROM ${TABLE_NAME} WHERE test_run_id = $1`, [ + TEST_RUN_ID, + ]) + await sql.end() +}, 30000) + +describeLivePg('v3 matrix live Postgres coverage (all 35 domains)', () => { + it.each( + eqDomains, + )('%s: eq_term/hmac_256 selects the exact row', async (eqlType) => { + const col = slug(eqlType) + const rows = await sql.unsafe<Row[]>( + `SELECT id FROM ${TABLE_NAME} + WHERE test_run_id = $1 + AND eql_v3.eq_term("${col}") = eql_v3_internal.hmac_256($2::jsonb)`, + [TEST_RUN_ID, sql.json(eqTerms[col] as never)], + ) + expect(rows.map((r) => r.id)).toEqual([idA]) + }) + + it.each( + ordDomains, + )('%s: ord_term/ore_block_256 equality-via-ORE selects the exact row', async (eqlType) => { + const col = slug(eqlType) + const rows = await sql.unsafe<Row[]>( + `SELECT id FROM ${TABLE_NAME} + WHERE test_run_id = $1 + AND eql_v3.ord_term("${col}") = eql_v3_internal.ore_block_256($2::jsonb)`, + [TEST_RUN_ID, sql.json(ordTerms[col] as never)], + ) + expect(rows.map((r) => r.id)).toEqual([idA]) + }) + + it.each( + matchDomains, + )('%s: match_term/bloom_filter selects row B (containing "ada"), not row A', async (eqlType) => { + const col = slug(eqlType) + const rows = await sql.unsafe<Row[]>( + `SELECT id FROM ${TABLE_NAME} + WHERE test_run_id = $1 + AND eql_v3.match_term("${col}") @> eql_v3_internal.bloom_filter($2::jsonb)`, + [TEST_RUN_ID, sql.json(matchTerms[col] as never)], + ) + expect(rows.map((r) => r.id)).toEqual([idB]) + }) + + it.each( + storageDomains, + )('%s: ciphertext survives a real INSERT/SELECT and still decrypts', async (eqlType, spec) => { + const col = slug(eqlType) + const [row] = await sql.unsafe<Array<{ value: unknown }>>( + `SELECT "${col}"::jsonb AS value FROM ${TABLE_NAME} WHERE id = $1`, + [idA], + ) + const decrypted = unwrapResult(await client.decrypt(row.value as never)) + const expected = spec.samples[0] + if (expected instanceof Date) { + // Lone-ciphertext decrypt has no column identity, so the cast_as-driven + // Date reconstruction (a decrypt-MODEL feature) cannot apply — the FFI + // returns the serialized instant (e.g. '2026-07-01T00:00:00Z'). Parse + // before comparing; toEqual on Dates compares the time value. + expect(new Date(decrypted as string)).toEqual(expected) + } else { + expect(decrypted).toBe(expected) + } + }) +}) diff --git a/packages/stack/__tests__/v3-matrix/matrix-live.test.ts b/packages/stack/__tests__/v3-matrix/matrix-live.test.ts new file mode 100644 index 00000000..ff51f02f --- /dev/null +++ b/packages/stack/__tests__/v3-matrix/matrix-live.test.ts @@ -0,0 +1,118 @@ +/** + * Live round-trip half of the type-driven v3 matrix — closes the "live cliff". + * + * The structural `matrix.test.ts` proves builder/eqlType/capabilities/`build()` + * wiring for all 35 domains WITHOUT ever touching real FFI ciphertext. This file + * completes the picture: every domain × every catalog `sample` is encrypted and + * decrypted through a live CipherStash client, so all 35 domains gain live + * behavioral proof (the Rust harness's whole premise) — not just 7. + * + * Round-trips go through the MODEL path (`encryptModel`/`decryptModel`) so + * `reconstructRow` rebuilds `Date` values uniformly for every plaintext axis; a + * lone single-value `decrypt` of a `date` domain returns an ISO string instead. + * + * The live work is BATCHED: one mega table spans every domain (one column each), + * and the whole sample set round-trips in a single `bulkEncryptModels` + + * `bulkDecryptModels` pair (2 network calls), not ~120 sequential ones. Error + * samples (NaN/±Infinity) use the single-value path — the guard throws + * client-side before any network — and so stay cheap even one at a time. + */ +import 'dotenv/config' +import { beforeAll, describe, expect, it } from 'vitest' +import { EncryptionV3, encryptedTable } from '@/encryption/v3' +import { unwrapResult } from '../fixtures' +import { describeLive, LIVE_CIPHERSTASH_ENABLED } from '../helpers/live-gate' +import { + type DomainSpec, + type EqlV3TypeName, + typedEntries, + V3_MATRIX, +} from './catalog' + +/** `eql_v3.integer_ord` → `integer_ord`: a valid, per-domain-unique column name. */ +const slug = (t: EqlV3TypeName): string => t.replace('eql_v3.', '') + +// `as const satisfies Record<...>` gives `V3_MATRIX` a narrower type than +// `Record<EqlV3TypeName, DomainSpec>` (rows that omit the optional +// `errorSamples` field literally lack that key, rather than typing it +// `undefined`). Explicit type arguments pin `typedEntries`'s inferred `V` back +// to the declared `DomainSpec` shape — without them, `spec` below is inferred +// as the union of all 35 distinct row literals, and `.errorSamples` fails to +// resolve on members that omit the key (`tsc` catches this; `vitest run` +// alone would not, since it only transpiles `.test.ts` files, never +// typechecks them). +const domains = typedEntries<EqlV3TypeName, DomainSpec>(V3_MATRIX) + +// One mega table: one column per catalog domain. Column names (the slugs) are +// unique and never collide with `EncryptedTable` reserved property names. +const columns = Object.fromEntries( + domains.map(([t, spec]) => [slug(t), spec.builder(slug(t))]), +) +const table = encryptedTable('v3_matrix_live', columns as never) + +// Batch the samples into as few model rows as the widest sample set requires: +// row `i` carries every domain's `samples[i]` (domains with fewer samples are +// simply absent from later rows, and `encryptModel` skips absent fields). +const maxSamples = Math.max(...domains.map(([, spec]) => spec.samples.length)) +const modelRows = Array.from({ length: maxSamples }, (_, i) => { + const row: Record<string, unknown> = {} + for (const [t, spec] of domains) { + if (i < spec.samples.length) row[slug(t)] = spec.samples[i] + } + return row +}) + +// Flatten to one assertion per (domain, sample) — labelled so vitest reports the +// exact domain + sample index that fails. +const roundTripCases = domains.flatMap(([t, spec]) => + spec.samples.map((sample, i) => [`${t} #${i}`, slug(t), sample, i] as const), +) +const errorCases = domains.flatMap(([t, spec]) => + (spec.errorSamples ?? []).map( + (bad) => [`${t} (${bad})`, slug(t), bad] as const, + ), +) + +describeLive('v3 matrix live round-trip (all domains × samples)', () => { + let client: Awaited<ReturnType<typeof EncryptionV3>> + let encrypted: Array<Record<string, unknown>> + let decrypted: Array<Record<string, unknown>> + + beforeAll(async () => { + client = await EncryptionV3({ schemas: [table] as never }) + encrypted = unwrapResult( + await client.bulkEncryptModels(modelRows as never, table as never), + ) as Array<Record<string, unknown>> + decrypted = unwrapResult( + await client.bulkDecryptModels(encrypted as never, table as never), + ) as Array<Record<string, unknown>> + }, 60000) + + it.each( + roundTripCases, + )('%s round-trips through the model path', (_label, col, sample, i) => { + // Guard against a false pass: the field must be a real ciphertext (`c`), + // not a plaintext value that slipped through un-encrypted. + expect(encrypted[i][col]).toHaveProperty('c') + + const actual = decrypted[i][col] + if (sample instanceof Date) { + expect(actual).toBeInstanceOf(Date) + expect(actual).toEqual(sample) + } else { + expect(actual).toStrictEqual(sample) + } + }) + + // Mirrors number-protect.test.ts: NaN/±Infinity must be rejected. The guard + // (encrypt.ts) throws client-side, so the single-value path is the honest place + // to prove where the rejection fires. + it.each(errorCases)('%s is rejected at encrypt', async (_label, col, bad) => { + const column = (table as unknown as Record<string, unknown>)[col] + const result = await client.encrypt(bad as never, { + table: table as never, + column: column as never, + }) + expect(result.failure).toBeDefined() + }) +}) diff --git a/packages/stack/__tests__/v3-matrix/matrix-lock-context.test.ts b/packages/stack/__tests__/v3-matrix/matrix-lock-context.test.ts new file mode 100644 index 00000000..d8041e33 --- /dev/null +++ b/packages/stack/__tests__/v3-matrix/matrix-lock-context.test.ts @@ -0,0 +1,158 @@ +/** + * Offline lock-context wiring for the v3 TYPED client. + * + * `lock-context-wiring.test.ts` proves the base (v2) client forwards + * `identityClaim` and never sends a `serviceToken`. This file proves the same + * for the v3 typed client — and specifically covers the one shape the v2 wiring + * cannot: `typedClient.decryptModel(model, table, lockContext)` takes the lock + * context as a POSITIONAL arg (not a `.withLockContext()` chain), and must still + * thread `identityClaim` through to the FFI. Mocks `@cipherstash/protect-ffi` so + * it runs deterministically in CI without credentials. + */ +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' +import { LockContext } from '@/identity' +import { Encryption } from '@/index' + +// A protect-ffi-shaped encrypted payload (passes `isEncryptedPayload`). +const enc = () => ({ v: 2, i: { t: 'users', c: 'email' }, c: 'ciphertext' }) + +vi.mock('@cipherstash/protect-ffi', () => ({ + newClient: vi.fn(async () => ({ __mock: 'client' })), + encrypt: vi.fn(async () => enc()), + decrypt: vi.fn(async () => 'decrypted'), + encryptBulk: vi.fn(async (_c: unknown, opts: { plaintexts: unknown[] }) => + opts.plaintexts.map(enc), + ), + decryptBulk: vi.fn(async (_c: unknown, opts: { ciphertexts: unknown[] }) => + opts.ciphertexts.map(() => 'decrypted'), + ), + decryptBulkFallible: vi.fn( + async (_c: unknown, opts: { ciphertexts: unknown[] }) => + opts.ciphertexts.map(() => ({ data: 'decrypted' })), + ), + encryptQuery: vi.fn(async () => enc()), + encryptQueryBulk: vi.fn(async (_c: unknown, opts: { queries: unknown[] }) => + opts.queries.map(enc), + ), +})) + +import * as ffi from '@cipherstash/protect-ffi' +import { encryptedTable, typedClient, types } from '@/encryption/v3' + +const users = encryptedTable('users', { + email: types.TextEq('email'), +}) + +const IDENTITY_CLAIM = { identityClaim: ['sub'] } +const lockCtx = () => new LockContext() + +/** Deep scan for a `serviceToken` key anywhere in a value. */ +function hasServiceToken(value: unknown): boolean { + if (Array.isArray(value)) return value.some(hasServiceToken) + if (value && typeof value === 'object') { + if ('serviceToken' in value) return true + return Object.values(value).some(hasServiceToken) + } + return false +} + +// biome-ignore lint/suspicious/noExplicitAny: test helper unwraps Result +function unwrap(result: any) { + if (result.failure) { + throw new Error(`operation failed: ${result.failure.message}`) + } + return result.data +} + +/** Options the operation was last called with (second arg to the ffi fn). */ +// biome-ignore lint/suspicious/noExplicitAny: reading recorded mock args +const lastOpts = (fn: any) => fn.mock.calls.at(-1)[1] + +let typed: ReturnType<typeof typedClient> +let prevWorkspaceCrn: string | undefined + +beforeEach(async () => { + vi.clearAllMocks() + prevWorkspaceCrn = process.env.CS_WORKSPACE_CRN + process.env.CS_WORKSPACE_CRN = 'crn:ap-southeast-2.aws:test-workspace' + typed = typedClient(await Encryption({ schemas: [users] as never }), users) +}) + +afterEach(() => { + // Restore the prior value so this suite doesn't leak env state into + // other Vitest suites sharing the worker. + if (prevWorkspaceCrn === undefined) { + delete process.env.CS_WORKSPACE_CRN + } else { + process.env.CS_WORKSPACE_CRN = prevWorkspaceCrn + } +}) + +describe('v3 typed client lock-context wiring', () => { + it('encrypt().withLockContext() forwards identityClaim, no serviceToken', async () => { + unwrap( + await typed + .encrypt('alice@example.com', { table: users, column: users.email }) + .withLockContext(lockCtx()), + ) + const opts = lastOpts(ffi.encrypt) + expect(opts.lockContext).toEqual(IDENTITY_CLAIM) + expect(hasServiceToken(opts)).toBe(false) + }) + + it('encrypt().withLockContext() accepts a plain { identityClaim } object', async () => { + unwrap( + await typed + .encrypt('alice@example.com', { table: users, column: users.email }) + .withLockContext({ identityClaim: ['sub'] }), + ) + const opts = lastOpts(ffi.encrypt) + expect(opts.lockContext).toEqual(IDENTITY_CLAIM) + expect(hasServiceToken(opts)).toBe(false) + }) + + it('encryptModel().withLockContext() forwards per-payload identityClaim', async () => { + unwrap( + await typed + .encryptModel({ email: 'alice@example.com' }, users) + .withLockContext(lockCtx()), + ) + const opts = lastOpts(ffi.encryptBulk) + expect(opts.plaintexts[0].lockContext).toEqual(IDENTITY_CLAIM) + expect(hasServiceToken(opts)).toBe(false) + }) + + // The v3-specific path: lockContext supplied as a POSITIONAL 3rd arg, not a + // chain. Must still reach the FFI. + it('decryptModel(model, table, { identityClaim }) forwards identityClaim positionally', async () => { + unwrap( + await typed.decryptModel({ email: enc() }, users, { + identityClaim: ['sub'], + }), + ) + const opts = lastOpts(ffi.decryptBulk) + expect(opts.ciphertexts[0].lockContext).toEqual(IDENTITY_CLAIM) + expect(hasServiceToken(opts)).toBe(false) + }) + + it('decryptModel(model, table, lockContext) accepts a LockContext instance positionally', async () => { + unwrap(await typed.decryptModel({ email: enc() }, users, lockCtx())) + const opts = lastOpts(ffi.decryptBulk) + expect(opts.ciphertexts[0].lockContext).toEqual(IDENTITY_CLAIM) + expect(hasServiceToken(opts)).toBe(false) + }) + + it('bulkDecryptModels(rows, table, lockContext) forwards per-row identityClaim', async () => { + unwrap(await typed.bulkDecryptModels([{ email: enc() }], users, lockCtx())) + const opts = lastOpts(ffi.decryptBulk) + expect(opts.ciphertexts[0].lockContext).toEqual(IDENTITY_CLAIM) + expect(hasServiceToken(opts)).toBe(false) + }) + + it('decryptModel WITHOUT a lock context sends neither lockContext nor serviceToken', async () => { + unwrap(await typed.decryptModel({ email: enc() }, users)) + const opts = lastOpts(ffi.decryptBulk) + expect(opts.ciphertexts[0].lockContext).toBeUndefined() + expect(hasServiceToken(opts)).toBe(false) + }) +}) diff --git a/packages/stack/__tests__/v3-matrix/matrix.test-d.ts b/packages/stack/__tests__/v3-matrix/matrix.test-d.ts new file mode 100644 index 00000000..26d51ba1 --- /dev/null +++ b/packages/stack/__tests__/v3-matrix/matrix.test-d.ts @@ -0,0 +1,97 @@ +/** + * Type-level half of the type-driven v3 matrix. + * + * Runtime `.each` cannot parameterise a compile-time `expectTypeOf<T>()` by row + * data, so the type-level surface is asserted against a concrete mixed-tier + * table. The columns under test are constructed FROM the `V3_MATRIX` builders + * (via specific keys) rather than hand-copied — `as const satisfies` preserves + * each builder's precise return type, so one catalog genuinely drives both the + * runtime and type-level surfaces. + * + * Runs via `pnpm test:types` (picked up by the `.test-d.ts` typecheck glob). + */ +import { describe, expectTypeOf, it } from 'vitest' +import { + encryptedTable, + type InferPlaintext, + type QueryableColumnsOf, + type QueryTypesForColumn, +} from '@/eql/v3' +import { type EqlV3TypeName, V3_MATRIX } from './catalog' + +// One mixed-tier table spanning every capability tier + plaintext axis, built +// from the catalog's own builders. +const records = encryptedTable('records', { + count: V3_MATRIX['eql_v3.integer'].builder('count'), // number, storage-only + score: V3_MATRIX['eql_v3.integer_eq'].builder('score'), // number, equality + rank: V3_MATRIX['eql_v3.integer_ord'].builder('rank'), // number, order + range + createdAt: V3_MATRIX['eql_v3.timestamp_ord'].builder('created_at'), // date + email: V3_MATRIX['eql_v3.text_search'].builder('email'), // string, full-text + active: V3_MATRIX['eql_v3.boolean'].builder('active'), // boolean, storage-only +}) + +describe('eql_v3 type-driven matrix (types)', () => { + it('maps each column to its plaintext axis', () => { + expectTypeOf<InferPlaintext<typeof records>>().toEqualTypeOf<{ + count: number + score: number + rank: number + createdAt: Date + email: string + active: boolean + }>() + }) + + it('derives the queryType union per column from its capabilities', () => { + expectTypeOf< + QueryTypesForColumn<typeof records.count> + >().toEqualTypeOf<never>() + expectTypeOf< + QueryTypesForColumn<typeof records.score> + >().toEqualTypeOf<'equality'>() + expectTypeOf<QueryTypesForColumn<typeof records.rank>>().toEqualTypeOf< + 'equality' | 'orderAndRange' + >() + expectTypeOf<QueryTypesForColumn<typeof records.createdAt>>().toEqualTypeOf< + 'equality' | 'orderAndRange' + >() + expectTypeOf<QueryTypesForColumn<typeof records.email>>().toEqualTypeOf< + 'equality' | 'orderAndRange' | 'freeTextSearch' + >() + expectTypeOf< + QueryTypesForColumn<typeof records.active> + >().toEqualTypeOf<never>() + }) + + it('excludes storage-only columns from the queryable set', () => { + type Queryable = QueryableColumnsOf<typeof records> + + // A queryable column is a member of the set... + const ok: Queryable = V3_MATRIX['eql_v3.integer_eq'].builder('score') + expectTypeOf(ok).toExtend<Queryable>() + + // ...but a storage-only column is not. + // @ts-expect-error - storage-only integer column is excluded from QueryableColumnsOf + const _notQueryable: Queryable = + V3_MATRIX['eql_v3.integer'].builder('count') + + // @ts-expect-error - storage-only boolean column is excluded from QueryableColumnsOf + const _boolNotQueryable: Queryable = + V3_MATRIX['eql_v3.boolean'].builder('active') + }) + + it('anchors the catalog key union to the real column source of truth', () => { + // `EqlV3TypeName` is derived from `AnyEncryptedV3Column`, so every real + // domain name is a member — no hand-copied list. + expectTypeOf<'eql_v3.text_search'>().toExtend<EqlV3TypeName>() + expectTypeOf<'eql_v3.boolean'>().toExtend<EqlV3TypeName>() + + // A key outside the real domain set is rejected — this is what makes the + // `Record<EqlV3TypeName, DomainSpec>` catalog a compile-time coverage check. + const bad: Partial<Record<EqlV3TypeName, number>> = { + // @ts-expect-error - 'eql_v3.nope' is not a member of EqlV3TypeName + 'eql_v3.nope': 1, + } + void bad + }) +}) diff --git a/packages/stack/__tests__/v3-matrix/matrix.test.ts b/packages/stack/__tests__/v3-matrix/matrix.test.ts new file mode 100644 index 00000000..c2bdf320 --- /dev/null +++ b/packages/stack/__tests__/v3-matrix/matrix.test.ts @@ -0,0 +1,36 @@ +/** + * Runtime half of the type-driven v3 matrix. + * + * A single `it.each` over the `V3_MATRIX` catalog asserts the full per-domain + * contract for every EQL v3 scalar domain. This SUPERSEDES the hand-rolled + * `domainCases` loop that previously lived in `schema-v3.test.ts`: the `build()` + * `toStrictEqual` here is byte-for-byte the same assertion, driven off the + * shared source of truth. Adding a domain row extends coverage automatically. + */ +import { describe, expect, it } from 'vitest' +import { typedEntries, V3_MATRIX } from './catalog' + +describe('eql_v3 type-driven domain matrix (runtime)', () => { + // `typedEntries` keeps `eqlType` as `EqlV3TypeName` rather than widening to + // `string`, so the key stays precisely typed through the callback. + it.each( + typedEntries(V3_MATRIX), + )('%s: builder, eqlType, capabilities and build() are consistent', (eqlType, spec) => { + const col = spec.builder('value') + + expect(col).toBeInstanceOf(spec.ColumnClass) + expect(col.getName()).toBe('value') + expect(col.getEqlType()).toBe(eqlType) + expect(col.getQueryCapabilities()).toStrictEqual(spec.capabilities) + expect(col.isQueryable()).toBe( + Object.values(spec.capabilities).some(Boolean), + ) + + // Full-fidelity `build()` check: exactly `{ cast_as, indexes }`, no extra + // keys — so SDK-facing metadata (eqlType/capabilities) can never leak. + expect(col.build()).toStrictEqual({ + cast_as: spec.castAs, + indexes: spec.indexes, + }) + }) +}) diff --git a/packages/stack/__tests__/wasm-inline-column-name.test.ts b/packages/stack/__tests__/wasm-inline-column-name.test.ts new file mode 100644 index 00000000..ee03ecf1 --- /dev/null +++ b/packages/stack/__tests__/wasm-inline-column-name.test.ts @@ -0,0 +1,46 @@ +import { describe, expect, it, vi } from 'vitest' + +// This unit test only covers `getColumnName`, which resolves a column's name +// structurally and never touches WASM. Mock the `/wasm-inline` specifiers so +// Vitest can load `../src/wasm-inline` without resolving the real inlined WASM +// entries (which aren't exported for the test bundler). +vi.mock('@cipherstash/auth/wasm-inline', () => ({ + AccessKeyStrategy: { + create: vi.fn(), + }, +})) + +vi.mock('@cipherstash/protect-ffi/wasm-inline', () => ({ + decrypt: vi.fn(), + encrypt: vi.fn(), + isEncrypted: vi.fn(), + newClient: vi.fn(), +})) + +import { types } from '../src/eql/v3' +import { encryptedColumn, encryptedField } from '../src/schema' +import { getColumnName } from '../src/wasm-inline' + +describe('wasm-inline getColumnName', () => { + it('returns the name for a v2 EncryptedColumn', () => { + expect(getColumnName(encryptedColumn('email'))).toBe('email') + }) + + it('returns the name for a v2 EncryptedField', () => { + expect(getColumnName(encryptedField('profile'))).toBe('profile') + }) + + it('returns the name for a v3 EncryptedTextSearchColumn (structural, no instanceof)', () => { + // Regression: widening EncryptOptions.column to the structural + // BuildableColumn made v3 columns type-check at the wasm-inline encrypt + // entry, but the old `instanceof EncryptedColumn || EncryptedField` gate + // threw at runtime. The entry now resolves the name structurally so a v3 + // column genuinely round-trips through WasmEncryptionClient.encrypt(). + expect(getColumnName(types.TextSearch('email'))).toBe('email') + }) + + it('throws when given a value that does not expose getName()', () => { + // Plain JS callers can bypass the type system — guard at runtime. + expect(() => getColumnName({} as never)).toThrow(/getName/) + }) +}) diff --git a/packages/stack/__tests__/wasm-inline-new-client.test.ts b/packages/stack/__tests__/wasm-inline-new-client.test.ts new file mode 100644 index 00000000..b33c4d72 --- /dev/null +++ b/packages/stack/__tests__/wasm-inline-new-client.test.ts @@ -0,0 +1,115 @@ +/** + * Offline coverage for the WASM `Encryption` factory's `newClient` call shape. + * + * protect-ffi 0.25 changed `newClient` from a two-argument form + * (`newClient(strategy, options)`) to a single options object with the + * strategy nested under `strategy`: + * `newClient({ strategy, encryptConfig, clientId, clientKey })`. + * + * `wasm-inline.ts` performs that migration, but the only end-to-end exercise + * of the factory is the Deno e2e (`e2e/wasm/roundtrip.test.ts`), which skips + * without real `CS_*` secrets — so a regression in the call shape (e.g. + * reverting to the two-arg form, dropping `clientId`/`clientKey`, or failing to + * normalise `cast_as`) would pass the normal suite. These tests mock the WASM + * bindings and assert the exact argument object handed to `wasmNewClient`. + */ + +import { beforeEach, describe, expect, it, vi } from 'vitest' + +vi.mock('@cipherstash/auth/wasm-inline', () => ({ + AccessKeyStrategy: { + create: vi.fn(() => ({ __mock: 'access-key-strategy' })), + }, + OidcFederationStrategy: class {}, +})) + +vi.mock('@cipherstash/protect-ffi/wasm-inline', () => ({ + newClient: vi.fn(async () => ({ __mock: 'wasm-client' })), + encrypt: vi.fn(), + decrypt: vi.fn(), + isEncrypted: vi.fn(), +})) + +import { newClient as wasmNewClient } from '@cipherstash/protect-ffi/wasm-inline' +import { Encryption, encryptedColumn, encryptedTable } from '../src/wasm-inline' + +const CRN = 'crn:ap-southeast-2.aws:test-workspace' + +const users = encryptedTable('users', { + email: encryptedColumn('email'), +}) + +beforeEach(() => { + vi.clearAllMocks() +}) + +describe('wasm-inline Encryption → newClient (protect-ffi 0.25 single-object form)', () => { + it('calls newClient with a single options object, not the 0.24 two-arg form', async () => { + await Encryption({ + schemas: [users], + config: { + workspaceCrn: CRN, + accessKey: 'CSAK.test', + clientId: 'cid', + clientKey: 'ckey', + }, + }) + + expect(vi.mocked(wasmNewClient)).toHaveBeenCalledTimes(1) + // The 0.24 form passed the strategy as a separate first positional arg. + // The 0.25 form is a single object — guard against regressing to two args. + const call = vi.mocked(wasmNewClient).mock.calls[0] + expect(call).toHaveLength(1) + }) + + it('nests the resolved strategy and forwards clientId / clientKey', async () => { + await Encryption({ + schemas: [users], + config: { + workspaceCrn: CRN, + accessKey: 'CSAK.test', + clientId: 'cid', + clientKey: 'ckey', + }, + }) + + // biome-ignore lint/suspicious/noExplicitAny: reading the recorded single options object + const arg = vi.mocked(wasmNewClient).mock.calls[0][0] as any + expect(arg.strategy).toEqual({ __mock: 'access-key-strategy' }) + expect(arg.clientId).toBe('cid') + expect(arg.clientKey).toBe('ckey') + }) + + it('passes a cast_as-normalised encryptConfig (SDK "string" → EQL "text")', async () => { + // `encryptedColumn('email')` defaults to `cast_as: 'string'`; the WASM + // client only accepts EQL-native variants, so the factory must run the + // config through `normalizeCastAs` before handing it to `newClient`. + await Encryption({ + schemas: [users], + config: { + workspaceCrn: CRN, + accessKey: 'CSAK.test', + clientId: 'cid', + clientKey: 'ckey', + }, + }) + + // biome-ignore lint/suspicious/noExplicitAny: navigating the recorded encryptConfig + const arg = vi.mocked(wasmNewClient).mock.calls[0][0] as any + expect(arg.encryptConfig).toBeDefined() + expect(arg.encryptConfig.tables.users.email.cast_as).toBe('text') + }) + + it('uses an explicit config.strategy verbatim on the strategy path', async () => { + const explicit = { getToken: vi.fn() } + await Encryption({ + schemas: [users], + // biome-ignore lint/suspicious/noExplicitAny: exercise the strategy arm of the config union + config: { strategy: explicit, clientId: 'cid', clientKey: 'ckey' } as any, + }) + + // biome-ignore lint/suspicious/noExplicitAny: reading the recorded single options object + const arg = vi.mocked(wasmNewClient).mock.calls[0][0] as any + expect(arg.strategy).toBe(explicit) + }) +}) diff --git a/packages/stack/__tests__/wasm-inline-normalize.test.ts b/packages/stack/__tests__/wasm-inline-normalize.test.ts index 77afbb5e..5f6bfd56 100644 --- a/packages/stack/__tests__/wasm-inline-normalize.test.ts +++ b/packages/stack/__tests__/wasm-inline-normalize.test.ts @@ -10,6 +10,7 @@ const EXPECTED_MAPPING: Readonly<Record<string, string>> = { bigint: 'big_int', boolean: 'boolean', date: 'date', + timestamp: 'timestamp', number: 'double', string: 'text', json: 'jsonb', diff --git a/packages/stack/__tests__/wasm-inline-strategy.test.ts b/packages/stack/__tests__/wasm-inline-strategy.test.ts index b082b9fd..4880bc43 100644 --- a/packages/stack/__tests__/wasm-inline-strategy.test.ts +++ b/packages/stack/__tests__/wasm-inline-strategy.test.ts @@ -58,6 +58,26 @@ describe('wasm-inline resolveStrategy', () => { expect(vi.mocked(AccessKeyStrategy.create)).not.toHaveBeenCalled() }) + it('throws when the access-key arm is missing workspaceCrn or accessKey', () => { + // JS callers bypass the compile-time union, so the no-strategy arm must + // reject a missing CRN or access key instead of forwarding `undefined` + // into `AccessKeyStrategy.create`. + expect(() => + // biome-ignore lint/suspicious/noExplicitAny: deliberately invalid — no strategy, no accessKey + resolveStrategy({ workspaceCrn: CRN } as any), + ).toThrowError( + /`config\.workspaceCrn` and `config\.accessKey` are required/, + ) + expect(() => + // biome-ignore lint/suspicious/noExplicitAny: deliberately invalid — no strategy, no workspaceCrn + resolveStrategy({ accessKey: 'CSAK.test' } as any), + ).toThrowError( + /`config\.workspaceCrn` and `config\.accessKey` are required/, + ) + // The guard must short-circuit *before* building a strategy. + expect(vi.mocked(AccessKeyStrategy.create)).not.toHaveBeenCalled() + }) + it('throws when both strategy and accessKey are supplied', () => { const both = { workspaceCrn: CRN, diff --git a/packages/stack/package.json b/packages/stack/package.json index fbdf6b68..c4bcacc6 100644 --- a/packages/stack/package.json +++ b/packages/stack/package.json @@ -51,6 +51,12 @@ "schema": [ "./dist/schema/index.d.ts" ], + "eql/v3": [ + "./dist/eql/v3/index.d.ts" + ], + "v3": [ + "./dist/encryption/v3.d.ts" + ], "types": [ "./dist/types-public.d.ts" ], @@ -119,6 +125,26 @@ "default": "./dist/schema/index.cjs" } }, + "./eql/v3": { + "import": { + "types": "./dist/eql/v3/index.d.ts", + "default": "./dist/eql/v3/index.js" + }, + "require": { + "types": "./dist/eql/v3/index.d.cts", + "default": "./dist/eql/v3/index.cjs" + } + }, + "./v3": { + "import": { + "types": "./dist/encryption/v3.d.ts", + "default": "./dist/encryption/v3.js" + }, + "require": { + "types": "./dist/encryption/v3.d.cts", + "default": "./dist/encryption/v3.cjs" + } + }, "./types": { "import": { "types": "./dist/types-public.d.ts", @@ -191,7 +217,10 @@ "prebuild": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\"", "build": "tsup", "dev": "tsup --watch", + "analyze:complexity": "fta src/eql/v3 --score-cap 72", + "db:eql-v3:install": "tsx scripts/install-eql-v3.ts", "test": "vitest run", + "test:types": "vitest --run --typecheck.only", "release": "tsup" }, "devDependencies": { @@ -201,6 +230,7 @@ "dotenv": "17.4.2", "drizzle-orm": "^0.45.2", "execa": "^9.5.2", + "fta-cli": "3.0.0", "json-schema-to-typescript": "^15.0.2", "postgres": "^3.4.8", "tsup": "catalog:repo", @@ -214,7 +244,7 @@ "dependencies": { "@byteslice/result": "0.2.0", "@cipherstash/auth": "catalog:repo", - "@cipherstash/protect-ffi": "0.26.0", + "@cipherstash/protect-ffi": "0.27.0", "evlog": "1.11.0", "uuid": "14.0.0", "zod": "3.25.76" diff --git a/packages/stack/scripts/install-eql-v3.ts b/packages/stack/scripts/install-eql-v3.ts new file mode 100644 index 00000000..e55eba79 --- /dev/null +++ b/packages/stack/scripts/install-eql-v3.ts @@ -0,0 +1,27 @@ +import { config } from 'dotenv' + +// Load env files in Next.js precedence order (.env.local wins over .env for the +// same key, since dotenv does not overwrite already-set vars). `quiet: true` +// suppresses dotenv v17's `injected env (N) from …` banner so this script does +// not print noisy, non-deterministic lines in CI. Mirrors the CLI entrypoint +// (packages/cli/src/bin/main.ts). +config({ path: '.env.local', quiet: true }) +config({ path: '.env.development.local', quiet: true }) +config({ path: '.env.development', quiet: true }) +config({ path: '.env', quiet: true }) + +import postgres from 'postgres' +import { installEqlV3IfNeeded } from '../__tests__/helpers/eql-v3' + +if (!process.env.DATABASE_URL) { + throw new Error('Missing env.DATABASE_URL') +} + +const sql = postgres(process.env.DATABASE_URL, { prepare: false }) + +try { + await installEqlV3IfNeeded(sql) + console.log('eql_v3.text_search is installed') +} finally { + await sql.end() +} diff --git a/packages/stack/src/encryption/helpers/index.ts b/packages/stack/src/encryption/helpers/index.ts index 164da509..78c1371e 100644 --- a/packages/stack/src/encryption/helpers/index.ts +++ b/packages/stack/src/encryption/helpers/index.ts @@ -1,22 +1,27 @@ import type { Encrypted as CipherStashEncrypted, EncryptedQuery as CipherStashEncryptedQuery, + EncryptedV3Query as CipherStashEncryptedV3Query, KeysetIdentifier as KeysetIdentifierFfi, } from '@cipherstash/protect-ffi' import type { Encrypted, EncryptedQueryResult, KeysetIdentifier } from '@/types' /** * The shape `encryptQuery` / `encryptQueryBulk` can return: a full storage - * payload (returned for `ste_vec_term` containment queries) or a query-only + * payload (returned for v2 `ste_vec_term` containment queries), a query-only * payload with no ciphertext (scalar `unique`/`match`/`ore` lookups and - * `ste_vec_selector` path queries). + * `ste_vec_selector` path queries), or — under `eqlVersion: 3` — the + * `eql_v3.jsonb_query` containment needle. * * TODO: duplicated in `@cipherstash/protect` — see * `packages/protect/src/helpers/index.ts`. Both copies should be removed once * `@cipherstash/protect-ffi` exports a named alias for the `encryptQuery` * return type (https://github.com/cipherstash/stack/pull/473). */ -type EncryptedQueryTerm = CipherStashEncrypted | CipherStashEncryptedQuery +type EncryptedQueryTerm = + | CipherStashEncrypted + | CipherStashEncryptedQuery + | CipherStashEncryptedV3Query export type EncryptedPgComposite = { data: Encrypted diff --git a/packages/stack/src/encryption/helpers/infer-index-type.ts b/packages/stack/src/encryption/helpers/infer-index-type.ts index 80eaf6ad..83cd0388 100644 --- a/packages/stack/src/encryption/helpers/infer-index-type.ts +++ b/packages/stack/src/encryption/helpers/infer-index-type.ts @@ -1,13 +1,17 @@ -import type { JsPlaintext, QueryOpName } from '@cipherstash/protect-ffi' -import type { EncryptedColumn } from '@/schema' -import type { FfiIndexTypeName, QueryTypeName } from '../../types' +import type { QueryOpName } from '@cipherstash/protect-ffi' +import type { + BuildableQueryColumn, + FfiIndexTypeName, + Plaintext, + QueryTypeName, +} from '../../types' import { queryTypeToFfi, queryTypeToQueryOp } from '../../types' /** * Infer the primary index type from a column's configured indexes. * Priority: unique > match > ore > ste_vec (for scalar queries) */ -export function inferIndexType(column: EncryptedColumn): FfiIndexTypeName { +export function inferIndexType(column: BuildableQueryColumn): FfiIndexTypeName { const config = column.build() const indexes = config.indexes @@ -31,16 +35,16 @@ export function inferIndexType(column: EncryptedColumn): FfiIndexTypeName { * - String → ste_vec_selector (JSONPath queries like '$.user.email') * - Object/Array/Number/Boolean → ste_vec_term (containment queries) */ -export function inferQueryOpFromPlaintext(plaintext: JsPlaintext): QueryOpName { +export function inferQueryOpFromPlaintext(plaintext: Plaintext): QueryOpName { if (typeof plaintext === 'string') { return 'ste_vec_selector' } - // Objects, arrays, numbers, booleans are all valid JSONB containment values + // Objects (incl. Date), arrays, numbers, booleans are all valid JSONB + // containment values if ( typeof plaintext === 'object' || typeof plaintext === 'number' || - typeof plaintext === 'boolean' || - typeof plaintext === 'bigint' + typeof plaintext === 'boolean' ) { return 'ste_vec_term' } @@ -52,7 +56,7 @@ export function inferQueryOpFromPlaintext(plaintext: JsPlaintext): QueryOpName { * Validate that the specified index type is configured on the column */ export function validateIndexType( - column: EncryptedColumn, + column: BuildableQueryColumn, indexType: FfiIndexTypeName, ): void { const config = column.build() @@ -72,6 +76,27 @@ export function validateIndexType( } } +/** + * v3-only: an order-capable column answers EQUALITY via its `ore` (`ob`) index. + * + * The v3 capability contract (`src/eql/v3`) documents `equality` as "exact-match + * lookups (EQL `hm`, or comparison via `ob`)", so an order-capable column with only + * an `ore` index still supports equality — the equality-vs-range distinction is made + * by the SQL comparison operator (`=` vs `>=`), NOT by the ciphertext (the FFI emits + * the same `ob` term either way). The default `equality → unique` mapping would + * wrongly reject these columns. + * + * Gated on `getQueryCapabilities`, which only v3 queryable columns expose — a v2 + * `EncryptedColumn` lacks it and so never matches, preserving v2's + * equality-without-unique throw unchanged (the no-v2-change constraint). + */ +function resolvesEqualityViaOre(column: BuildableQueryColumn): boolean { + if (!('getQueryCapabilities' in column)) return false + if (!column.getQueryCapabilities().equality) return false + const indexes = column.build().indexes ?? {} + return !indexes.unique && !!indexes.ore +} + /** * Resolve the index type and query operation for a query. * Validates the index type is configured on the column when queryType is explicit. @@ -84,15 +109,23 @@ export function validateIndexType( * @throws Error if ste_vec is inferred but queryOp cannot be determined */ export function resolveIndexType( - column: EncryptedColumn, + column: BuildableQueryColumn, queryType?: QueryTypeName, - plaintext?: JsPlaintext | null, + plaintext?: Plaintext | null, ): { indexType: FfiIndexTypeName; queryOp?: QueryOpName } { const indexType = queryType ? queryTypeToFfi[queryType] : inferIndexType(column) if (queryType) { + // An order-capable v3 column answers equality via its `ore` index (`ob` + // term) — the same term `orderAndRange` emits, distinguished only by the SQL + // `=` operator. Resolve to `ore` (queryOp undefined) instead of throwing on + // the missing `unique` index. v2 columns never enter here (see helper). + if (queryType === 'equality' && resolvesEqualityViaOre(column)) { + return { indexType: 'ore' } + } + validateIndexType(column, indexType) // For searchableJson, infer queryOp from plaintext type (not from mapping) diff --git a/packages/stack/src/encryption/helpers/model-helpers.ts b/packages/stack/src/encryption/helpers/model-helpers.ts index 4530746d..1ba3997a 100644 --- a/packages/stack/src/encryption/helpers/model-helpers.ts +++ b/packages/stack/src/encryption/helpers/model-helpers.ts @@ -6,8 +6,7 @@ import { import { isEncryptedPayload } from '@/encryption/helpers' import type { AuditData } from '@/encryption/operations/base-operation' import type { Context } from '@/identity' -import type { EncryptedTable, EncryptedTableColumn } from '@/schema' -import type { Client, Decrypted, Encrypted } from '@/types' +import type { BuildableTable, Client, Decrypted, Encrypted } from '@/types' /** * Sets a value at a nested path in an object, creating intermediate objects as needed. @@ -205,9 +204,35 @@ function prepareFieldsForDecryption<T extends Record<string, unknown>>( /** * Helper function to prepare fields for encryption */ +/** + * Resolve how a table's model fields map onto encrypt-config columns. + * + * `columnPaths` are the keys used to MATCH a user model's fields (the JS + * property names); `toColumnName` maps a matched field to the name the FFI / + * encrypt config is keyed by (the DB name). + * + * When a table exposes `buildColumnKeyMap()` (v3), those two can differ, so we + * match by property but address by DB name. Otherwise (v2) `build()` already + * keys columns by the property name, so both are that same key (identity map). + */ +export function resolveEncryptColumnMap(table: BuildableTable): { + columnPaths: string[] + toColumnName: (path: string) => string +} { + const keyMap = table.buildColumnKeyMap?.() + if (keyMap) { + return { + columnPaths: Object.keys(keyMap), + toColumnName: (path) => keyMap[path] ?? path, + } + } + const columnPaths = Object.keys(table.build().columns) + return { columnPaths, toColumnName: (path) => path } +} + function prepareFieldsForEncryption<T extends Record<string, unknown>>( model: T, - table: EncryptedTable<EncryptedTableColumn>, + table: BuildableTable, ): { otherFields: Record<string, unknown> operationFields: Record<string, unknown> @@ -264,8 +289,8 @@ function prepareFieldsForEncryption<T extends Record<string, unknown>>( } } - // Get all column paths from the table schema - const columnPaths = Object.keys(table.build().columns) + // Get all column paths from the table schema (matched by JS property name). + const { columnPaths } = resolveEncryptColumnMap(table) processNestedFields(model, '', columnPaths) return { otherFields, operationFields, keyMap, nullFields } @@ -326,7 +351,7 @@ export async function decryptModelFields<T extends Record<string, unknown>>( */ export async function encryptModelFields( model: Record<string, unknown>, - table: EncryptedTable<EncryptedTableColumn>, + table: BuildableTable, client: Client, auditData?: AuditData, ): Promise<Record<string, unknown>> { @@ -337,12 +362,13 @@ export async function encryptModelFields( const { otherFields, operationFields, keyMap, nullFields } = prepareFieldsForEncryption(model, table) + const { toColumnName } = resolveEncryptColumnMap(table) const bulkEncryptPayload = Object.entries(operationFields).map( ([key, value]) => ({ id: key, plaintext: value as string, table: table.tableName, - column: key, + column: toColumnName(key), }), ) @@ -437,7 +463,7 @@ export async function decryptModelFieldsWithLockContext< */ export async function encryptModelFieldsWithLockContext( model: Record<string, unknown>, - table: EncryptedTable<EncryptedTableColumn>, + table: BuildableTable, client: Client, lockContext: Context, auditData?: AuditData, @@ -453,12 +479,13 @@ export async function encryptModelFieldsWithLockContext( const { otherFields, operationFields, keyMap, nullFields } = prepareFieldsForEncryption(model, table) + const { toColumnName } = resolveEncryptColumnMap(table) const bulkEncryptPayload = Object.entries(operationFields).map( ([key, value]) => ({ id: key, plaintext: value as string, table: table.tableName, - column: key, + column: toColumnName(key), lockContext, }), ) @@ -496,7 +523,7 @@ export async function encryptModelFieldsWithLockContext( */ function prepareBulkModelsForOperation<T extends Record<string, unknown>>( models: T[], - table?: EncryptedTable<EncryptedTableColumn>, + table?: BuildableTable, ): { otherFields: Record<string, unknown>[] operationFields: Record<string, unknown>[] @@ -560,8 +587,8 @@ function prepareBulkModelsForOperation<T extends Record<string, unknown>>( } if (table) { - // Get all column paths from the table schema - const columnPaths = Object.keys(table.build().columns) + // Get all column paths from the table schema (matched by JS property name). + const { columnPaths } = resolveEncryptColumnMap(table) processNestedFields(model, '', columnPaths) } else { // For decryption, process all encrypted fields @@ -643,7 +670,7 @@ function fieldsForModelIndex( */ export async function bulkEncryptModels( models: Record<string, unknown>[], - table: EncryptedTable<EncryptedTableColumn>, + table: BuildableTable, client: Client, auditData?: AuditData, ): Promise<Record<string, unknown>[]> { @@ -658,12 +685,13 @@ export async function bulkEncryptModels( const { otherFields, operationFields, keyMap, nullFields } = prepareBulkModelsForOperation(models, table) + const { toColumnName } = resolveEncryptColumnMap(table) const bulkEncryptPayload = operationFields.flatMap((fields, modelIndex) => Object.entries(fields).map(([key, value]) => ({ id: `${modelIndex}-${key}`, plaintext: value as string, table: table.tableName, - column: key, + column: toColumnName(key), })), ) @@ -822,7 +850,7 @@ export async function bulkDecryptModelsWithLockContext< */ export async function bulkEncryptModelsWithLockContext( models: Record<string, unknown>[], - table: EncryptedTable<EncryptedTableColumn>, + table: BuildableTable, client: Client, lockContext: Context, auditData?: AuditData, @@ -838,12 +866,13 @@ export async function bulkEncryptModelsWithLockContext( const { otherFields, operationFields, keyMap, nullFields } = prepareBulkModelsForOperation(models, table) + const { toColumnName } = resolveEncryptColumnMap(table) const bulkEncryptPayload = operationFields.flatMap((fields, modelIndex) => Object.entries(fields).map(([key, value]) => ({ id: `${modelIndex}-${key}`, plaintext: value as string, table: table.tableName, - column: key, + column: toColumnName(key), lockContext, })), ) diff --git a/packages/stack/src/encryption/index.ts b/packages/stack/src/encryption/index.ts index ccf422e1..67a8c8c3 100644 --- a/packages/stack/src/encryption/index.ts +++ b/packages/stack/src/encryption/index.ts @@ -1,5 +1,5 @@ import { type Result, withResult } from '@byteslice/result' -import { type JsPlaintext, newClient } from '@cipherstash/protect-ffi' +import { newClient } from '@cipherstash/protect-ffi' import { validate as uuidValidate } from 'uuid' import { type EncryptionError, EncryptionErrorTypes } from '@/errors' // `LockContext` is imported type-only so the TSDoc {@link} references in the @@ -8,8 +8,6 @@ import type { LockContext } from '@/identity' import { buildEncryptConfig, type EncryptConfig, - type EncryptedTable, - type EncryptedTableColumn, encryptConfigSchema, // Imported type-only for the TSDoc {@link} references in the comments below. type encryptedColumn, @@ -18,15 +16,17 @@ import { } from '@/schema' import type { AuthStrategy, + BuildableTable, BulkDecryptPayload, BulkEncryptPayload, Client, Encrypted, - EncryptedFromSchema, + EncryptedFromBuildableTable, EncryptionClientConfig, EncryptOptions, EncryptQueryOptions, KeysetIdentifier, + Plaintext, ScalarQueryTerm, } from '@/types' import { logger } from '@/utils/logger' @@ -64,6 +64,47 @@ export const noClientError = () => 'The Encryption client has not been initialized. Please call init() before using the client.', ) +/** + * Resolve the EQL wire version for a client from its schema set. + * + * One FFI client emits exactly one wire format, so the whole schema set must + * agree. EQL v3 tables (from `@cipherstash/stack/v3`) are detected by their + * `buildColumnKeyMap()` marker — v2 tables don't have one: + * + * - every schema is v3 → `3`; + * - no schema is v3 → `undefined`, leaving the FFI's v2 default (and its + * byte-identical v2 output) untouched; + * - a mix of the two → throws: the v2 tables target `eql_v2_encrypted` + * columns and the v3 tables target `eql_v3` domains, so no single wire + * format serves both. Split them across two clients. + * + * An explicit `config.eqlVersion` bypasses detection (the wire format is + * then unambiguous — e.g. writing v2-wire from a v3 schema set during a + * migration), but a mixed schema set still throws. + * + * @internal exported for unit-test coverage of the detection matrix. + */ +export function resolveEqlVersion( + schemas: readonly BuildableTable[], + explicit?: 2 | 3, +): 2 | 3 | undefined { + const v3Count = schemas.filter( + (schema) => typeof schema.buildColumnKeyMap === 'function', + ).length + + if (v3Count > 0 && v3Count < schemas.length) { + throw new Error( + '[encryption]: cannot mix EQL v2 and EQL v3 tables in one client — one client emits exactly one wire format. Create separate clients for the v2 and v3 schemas.', + ) + } + + if (explicit !== undefined) { + return explicit + } + + return v3Count === 0 ? undefined : 3 +} + /** The EncryptionClient is the main entry point for interacting with the CipherStash Encryption library. * It provides methods for encrypting and decrypting individual values, as well as models (objects) and bulk operations. * @@ -87,6 +128,7 @@ export class EncryptionClient { clientKey?: string keyset?: KeysetIdentifier strategy?: AuthStrategy + eqlVersion?: 2 | 3 }): Promise<Result<EncryptionClient, EncryptionError>> { return await withResult( async () => { @@ -108,6 +150,10 @@ export class EncryptionClient { // from the credentials in clientOpts (the clientKey is still used // for encryption). Passing `strategy: undefined` is equivalent to // omitting it, so the default credentials path is unaffected. + // `eqlVersion` selects the wire format `encrypt`/`encryptQuery` + // emit (protect-ffi 0.27+); `eqlVersion: undefined` is likewise + // equivalent to omitting it, leaving the FFI's v2 default — and + // its byte-identical v2 output — untouched. this.client = await newClient({ encryptConfig: validated, clientOpts: { @@ -118,6 +164,7 @@ export class EncryptionClient { keyset: toFfiKeysetIdentifier(config.keyset), }, strategy: config.strategy, + eqlVersion: config.eqlVersion, }) this.encryptConfig = validated @@ -207,7 +254,7 @@ export class EncryptionClient { * @see {@link LockContext} * @see {@link EncryptOperation} */ - encrypt(plaintext: JsPlaintext, opts: EncryptOptions): EncryptOperation { + encrypt(plaintext: Plaintext, opts: EncryptOptions): EncryptOperation { return new EncryptOperation(this.client, plaintext, opts) } @@ -265,7 +312,7 @@ export class EncryptionClient { * - Object/Array plaintext → `steVecTerm` (containment queries like `{ role: 'admin' }`) */ encryptQuery( - plaintext: JsPlaintext, + plaintext: Plaintext, opts: EncryptQueryOptions, ): EncryptQueryOperation @@ -276,12 +323,14 @@ export class EncryptionClient { encryptQuery(terms: readonly ScalarQueryTerm[]): BatchEncryptQueryOperation encryptQuery( - plaintextOrTerms: JsPlaintext | readonly ScalarQueryTerm[], + plaintextOrTerms: Plaintext | readonly ScalarQueryTerm[], opts?: EncryptQueryOptions, ): EncryptQueryOperation | BatchEncryptQueryOperation { - // Discriminate between ScalarQueryTerm[] and JsPlaintext (which can also be an array) - // using a type guard function - if (isScalarQueryTermArray(plaintextOrTerms)) { + // Discriminate between ScalarQueryTerm[] and Plaintext (which can also be an + // array) using a type guard function. Only route to batch mode when no opts + // are supplied — an explicit EncryptQueryOptions forces the single-plaintext + // path even if the plaintext value happens to be an array. + if (!opts && isScalarQueryTermArray(plaintextOrTerms)) { return new BatchEncryptQueryOperation(this.client, plaintextOrTerms) } @@ -305,7 +354,7 @@ export class EncryptionClient { return new EncryptQueryOperation( this.client, - plaintextOrTerms as JsPlaintext, + plaintextOrTerms as Plaintext, opts, ) } @@ -399,13 +448,10 @@ export class EncryptionClient { * } * ``` */ - encryptModel< - T extends Record<string, unknown>, - S extends EncryptedTableColumn = EncryptedTableColumn, - >( + encryptModel<T extends Record<string, unknown>, Table extends BuildableTable>( input: T, - table: EncryptedTable<S>, - ): EncryptModelOperation<EncryptedFromSchema<T, S>> { + table: Table, + ): EncryptModelOperation<EncryptedFromBuildableTable<T, Table>> { return new EncryptModelOperation( this.client, input as Record<string, unknown>, @@ -494,11 +540,11 @@ export class EncryptionClient { */ bulkEncryptModels< T extends Record<string, unknown>, - S extends EncryptedTableColumn = EncryptedTableColumn, + Table extends BuildableTable, >( input: Array<T>, - table: EncryptedTable<S>, - ): BulkEncryptModelsOperation<EncryptedFromSchema<T, S>> { + table: Table, + ): BulkEncryptModelsOperation<EncryptedFromBuildableTable<T, Table>> { return new BulkEncryptModelsOperation( this.client, input as Array<Record<string, unknown>>, @@ -705,9 +751,16 @@ export const Encryption = async ( const client = new EncryptionClient() const encryptConfig = buildEncryptConfig(...schemas) + // Resolve the wire format for this client: an explicit + // `config.eqlVersion` wins; otherwise it is auto-detected from the + // schema set (v3 tables → 3, v2 tables → the FFI's v2 default). A mixed + // v2 + v3 schema set throws — one client emits exactly one wire format. + const eqlVersion = resolveEqlVersion(schemas, clientConfig?.eqlVersion) + const result = await client.init({ encryptConfig, ...clientConfig, + eqlVersion, }) if (result.failure) { diff --git a/packages/stack/src/encryption/operations/batch-encrypt-query.ts b/packages/stack/src/encryption/operations/batch-encrypt-query.ts index 1c4bff5c..ca5cfb3b 100644 --- a/packages/stack/src/encryption/operations/batch-encrypt-query.ts +++ b/packages/stack/src/encryption/operations/batch-encrypt-query.ts @@ -2,6 +2,7 @@ import { type Result, withResult } from '@byteslice/result' import type { Encrypted as CipherStashEncrypted, EncryptedQuery as CipherStashEncryptedQuery, + EncryptedV3Query as CipherStashEncryptedV3Query, } from '@cipherstash/protect-ffi' import { encryptQueryBulk as ffiEncryptQueryBulk, @@ -82,7 +83,11 @@ function buildQueryPayload( */ function assembleResults( totalLength: number, - encryptedValues: (CipherStashEncrypted | CipherStashEncryptedQuery)[], + encryptedValues: ( + | CipherStashEncrypted + | CipherStashEncryptedQuery + | CipherStashEncryptedV3Query + )[], nonNullTerms: { term: ScalarQueryTerm; originalIndex: number }[], ): EncryptedQueryResult[] { const results: EncryptedQueryResult[] = new Array(totalLength).fill(null) diff --git a/packages/stack/src/encryption/operations/bulk-encrypt-models.ts b/packages/stack/src/encryption/operations/bulk-encrypt-models.ts index 20d68496..10c22633 100644 --- a/packages/stack/src/encryption/operations/bulk-encrypt-models.ts +++ b/packages/stack/src/encryption/operations/bulk-encrypt-models.ts @@ -2,8 +2,7 @@ import { type Result, withResult } from '@byteslice/result' import { getErrorCode } from '@/encryption/helpers/error-code' import { type EncryptionError, EncryptionErrorTypes } from '@/errors' import { type LockContextInput, resolveLockContext } from '@/identity' -import type { EncryptedTable, EncryptedTableColumn } from '@/schema' -import type { Client } from '@/types' +import type { BuildableTable, Client } from '@/types' import { createRequestLogger } from '@/utils/logger' import { bulkEncryptModels, @@ -17,12 +16,12 @@ export class BulkEncryptModelsOperation< > extends EncryptionOperation<T[]> { private client: Client private models: Record<string, unknown>[] - private table: EncryptedTable<EncryptedTableColumn> + private table: BuildableTable constructor( client: Client, models: Record<string, unknown>[], - table: EncryptedTable<EncryptedTableColumn>, + table: BuildableTable, ) { super() this.client = client @@ -76,7 +75,7 @@ export class BulkEncryptModelsOperation< public getOperation(): { client: Client models: Record<string, unknown>[] - table: EncryptedTable<EncryptedTableColumn> + table: BuildableTable } { return { client: this.client, diff --git a/packages/stack/src/encryption/operations/bulk-encrypt.ts b/packages/stack/src/encryption/operations/bulk-encrypt.ts index 9b01825a..6e3ec802 100644 --- a/packages/stack/src/encryption/operations/bulk-encrypt.ts +++ b/packages/stack/src/encryption/operations/bulk-encrypt.ts @@ -8,12 +8,8 @@ import { resolveLockContext, } from '@/identity' import type { - EncryptedColumn, - EncryptedField, - EncryptedTable, - EncryptedTableColumn, -} from '@/schema' -import type { + BuildableColumn, + BuildableTable, BulkEncryptedData, BulkEncryptPayload, Client, @@ -29,8 +25,8 @@ import { EncryptionOperation } from './base-operation' // re-inserted as null in `mapEncryptedDataToResult`. const createEncryptPayloads = ( plaintexts: BulkEncryptPayload, - column: EncryptedColumn | EncryptedField, - table: EncryptedTable<EncryptedTableColumn>, + column: BuildableColumn, + table: BuildableTable, lockContext?: Context, ) => { return plaintexts @@ -67,8 +63,8 @@ const mapEncryptedDataToResult = ( export class BulkEncryptOperation extends EncryptionOperation<BulkEncryptedData> { private client: Client private plaintexts: BulkEncryptPayload - private column: EncryptedColumn | EncryptedField - private table: EncryptedTable<EncryptedTableColumn> + private column: BuildableColumn + private table: BuildableTable constructor( client: Client, @@ -142,8 +138,8 @@ export class BulkEncryptOperation extends EncryptionOperation<BulkEncryptedData> public getOperation(): { client: Client plaintexts: BulkEncryptPayload - column: EncryptedColumn | EncryptedField - table: EncryptedTable<EncryptedTableColumn> + column: BuildableColumn + table: BuildableTable } { return { client: this.client, diff --git a/packages/stack/src/encryption/operations/encrypt-model.ts b/packages/stack/src/encryption/operations/encrypt-model.ts index 1c39d66e..0ac42f08 100644 --- a/packages/stack/src/encryption/operations/encrypt-model.ts +++ b/packages/stack/src/encryption/operations/encrypt-model.ts @@ -2,8 +2,7 @@ import { type Result, withResult } from '@byteslice/result' import { getErrorCode } from '@/encryption/helpers/error-code' import { type EncryptionError, EncryptionErrorTypes } from '@/errors' import { type LockContextInput, resolveLockContext } from '@/identity' -import type { EncryptedTable, EncryptedTableColumn } from '@/schema' -import type { Client } from '@/types' +import type { BuildableTable, Client } from '@/types' import { createRequestLogger } from '@/utils/logger' import { encryptModelFields, @@ -17,12 +16,12 @@ export class EncryptModelOperation< > extends EncryptionOperation<T> { private client: Client private model: Record<string, unknown> - private table: EncryptedTable<EncryptedTableColumn> + private table: BuildableTable constructor( client: Client, model: Record<string, unknown>, - table: EncryptedTable<EncryptedTableColumn>, + table: BuildableTable, ) { super() this.client = client @@ -75,7 +74,7 @@ export class EncryptModelOperation< public getOperation(): { client: Client model: Record<string, unknown> - table: EncryptedTable<EncryptedTableColumn> + table: BuildableTable } { return { client: this.client, diff --git a/packages/stack/src/encryption/operations/encrypt-query.ts b/packages/stack/src/encryption/operations/encrypt-query.ts index c2c17b36..9369b91d 100644 --- a/packages/stack/src/encryption/operations/encrypt-query.ts +++ b/packages/stack/src/encryption/operations/encrypt-query.ts @@ -7,7 +7,12 @@ import { formatEncryptedResult } from '@/encryption/helpers' import { getErrorCode } from '@/encryption/helpers/error-code' import { type EncryptionError, EncryptionErrorTypes } from '@/errors' import { type LockContextInput, resolveLockContext } from '@/identity' -import type { Client, EncryptedQueryResult, EncryptQueryOptions } from '@/types' +import type { + Client, + EncryptedQueryResult, + EncryptQueryOptions, + Plaintext, +} from '@/types' import { createRequestLogger } from '@/utils/logger' import { resolveIndexType } from '../helpers/infer-index-type' import { @@ -20,7 +25,7 @@ import { EncryptionOperation } from './base-operation' export class EncryptQueryOperation extends EncryptionOperation<EncryptedQueryResult> { constructor( private client: Client, - private plaintext: JsPlaintext | null | undefined, + private plaintext: Plaintext | null | undefined, private opts: EncryptQueryOptions, ) { super() @@ -55,7 +60,7 @@ export class EncryptQueryOperation extends EncryptionOperation<EncryptedQueryRes return { data: null } } - const plaintext: JsPlaintext = this.plaintext + const plaintext: Plaintext = this.plaintext const validationError = validateNumericValue(plaintext) if (validationError?.failure) { @@ -83,7 +88,10 @@ export class EncryptQueryOperation extends EncryptionOperation<EncryptedQueryRes ) const encrypted = await ffiEncryptQuery(this.client, { - plaintext, + // `Plaintext` widens the FFI `JsPlaintext` with `Date` (serialized via + // `toJSON` at the boundary); cast until the upstream input union is + // corrected to include it. + plaintext: plaintext as JsPlaintext, column: this.opts.column.getName(), table: this.opts.table.tableName, indexType, @@ -114,7 +122,7 @@ export class EncryptQueryOperation extends EncryptionOperation<EncryptedQueryRes export class EncryptQueryOperationWithLockContext extends EncryptionOperation<EncryptedQueryResult> { constructor( private client: Client, - private plaintext: JsPlaintext | null | undefined, + private plaintext: Plaintext | null | undefined, private opts: EncryptQueryOptions, private lockContext: LockContextInput, auditMetadata?: Record<string, unknown>, @@ -140,7 +148,7 @@ export class EncryptQueryOperationWithLockContext extends EncryptionOperation<En return { data: null } } - const plaintext: JsPlaintext = this.plaintext + const plaintext: Plaintext = this.plaintext const validationError = validateNumericValue(plaintext) if (validationError?.failure) { @@ -170,7 +178,10 @@ export class EncryptQueryOperationWithLockContext extends EncryptionOperation<En ) const encrypted = await ffiEncryptQuery(this.client, { - plaintext, + // `Plaintext` widens the FFI `JsPlaintext` with `Date` (serialized via + // `toJSON` at the boundary); cast until the upstream input union is + // corrected to include it. + plaintext: plaintext as JsPlaintext, column: this.opts.column.getName(), table: this.opts.table.tableName, indexType, diff --git a/packages/stack/src/encryption/operations/encrypt.ts b/packages/stack/src/encryption/operations/encrypt.ts index 55ad7a30..de380613 100644 --- a/packages/stack/src/encryption/operations/encrypt.ts +++ b/packages/stack/src/encryption/operations/encrypt.ts @@ -4,15 +4,17 @@ import { type JsPlaintext, } from '@cipherstash/protect-ffi' import { getErrorCode } from '@/encryption/helpers/error-code' +import { assertValidNumericValue } from '@/encryption/helpers/validation' import { type EncryptionError, EncryptionErrorTypes } from '@/errors' import { type LockContextInput, resolveLockContext } from '@/identity' import type { - EncryptedColumn, - EncryptedField, - EncryptedTable, - EncryptedTableColumn, -} from '@/schema' -import type { Client, Encrypted, EncryptOptions } from '@/types' + BuildableColumn, + BuildableTable, + Client, + Encrypted, + EncryptOptions, + Plaintext, +} from '@/types' import { createRequestLogger } from '@/utils/logger' import { noClientError } from '../index' import { EncryptionOperation } from './base-operation' @@ -23,13 +25,13 @@ export class EncryptOperation extends EncryptionOperation<Encrypted> { // short-circuit. The public `Encryption.encrypt()` signature still // rejects null at the type layer; this is defense in depth for callers // that reach this class through casts or dynamic field walking. - private plaintext: JsPlaintext | null - private column: EncryptedColumn | EncryptedField - private table: EncryptedTable<EncryptedTableColumn> + private plaintext: Plaintext | null + private column: BuildableColumn + private table: BuildableTable constructor( client: Client, - plaintext: JsPlaintext | null, + plaintext: Plaintext | null, opts: EncryptOptions, ) { super() @@ -70,24 +72,15 @@ export class EncryptOperation extends EncryptionOperation<Encrypted> { return null as unknown as Encrypted } - if ( - typeof this.plaintext === 'number' && - Number.isNaN(this.plaintext) - ) { - throw new Error('[encryption]: Cannot encrypt NaN value') - } - - if ( - typeof this.plaintext === 'number' && - !Number.isFinite(this.plaintext) - ) { - throw new Error('[encryption]: Cannot encrypt Infinity value') - } + assertValidNumericValue(this.plaintext) const { metadata } = this.getAuditData() return await ffiEncrypt(this.client, { - plaintext: this.plaintext, + // `Plaintext` widens the FFI `JsPlaintext` with `Date` (serialized via + // `toJSON` at the boundary); cast until the upstream `JsPlaintext` input + // union is corrected to include it. + plaintext: this.plaintext as JsPlaintext, column: this.column.getName(), table: this.table.tableName, unverifiedContext: metadata, @@ -108,9 +101,9 @@ export class EncryptOperation extends EncryptionOperation<Encrypted> { public getOperation(): { client: Client - plaintext: JsPlaintext | null - column: EncryptedColumn | EncryptedField - table: EncryptedTable<EncryptedTableColumn> + plaintext: Plaintext | null + column: BuildableColumn + table: BuildableTable } { return { client: this.client, @@ -156,11 +149,13 @@ export class EncryptOperationWithLockContext extends EncryptionOperation<Encrypt return null as unknown as Encrypted } + assertValidNumericValue(plaintext) + const { metadata } = this.getAuditData() const lockContext = resolveLockContext(this.lockContext) return await ffiEncrypt(client, { - plaintext, + plaintext: plaintext as JsPlaintext, column: column.getName(), table: table.tableName, lockContext, diff --git a/packages/stack/src/encryption/v3.ts b/packages/stack/src/encryption/v3.ts new file mode 100644 index 00000000..bdf3734c --- /dev/null +++ b/packages/stack/src/encryption/v3.ts @@ -0,0 +1,251 @@ +import type { Result } from '@byteslice/result' +import type { + AnyV3Table, + ColumnsOf, + PlaintextForColumn, + QueryableColumnsOf, + QueryTypesForColumn, + V3DecryptedModel, + V3EncryptedModel, + V3ModelInput, +} from '@/eql/v3' +import type { EncryptionError } from '@/errors' +import type { LockContextInput } from '@/identity' +import type { + BulkDecryptPayload, + BulkEncryptPayload, + ClientConfig, + Encrypted, + EncryptedReturnType, + EncryptOptions, +} from '@/types' +import { + type BulkDecryptOperation, + type BulkEncryptModelsOperation, + type BulkEncryptOperation, + type DecryptOperation, + Encryption, + type EncryptionClient, + type EncryptModelOperation, + type EncryptOperation, + type EncryptQueryOperation, +} from './index' + +/** + * A strongly-typed view over an {@link EncryptionClient} for EQL v3 schemas. + * + * Every method derives its types from the concrete `table` / `column` builder + * arguments (which carry their branded types at the call site), so: + * - `encrypt` / `encryptQuery` pin the plaintext to the column's domain type + * (`text → string`, `timestamp → Date`, …); + * - `encryptQuery` additionally constrains `queryType` to the column's + * capabilities and rejects storage-only columns outright; + * - `encryptModel` / `bulkEncryptModels` validate schema-column fields against + * their inferred plaintext type (passthrough fields are untouched) and return + * a precise encrypted model; + * - `decryptModel` / `bulkDecryptModels` return the precise plaintext model, + * reconstructing `Date` values from the encrypt-config `cast_as`. + * + * @typeParam S - the tuple of registered v3 tables; `table` arguments must be a + * member of this tuple. + */ +export interface TypedEncryptionClient<S extends readonly AnyV3Table[]> { + encrypt<Table extends S[number], Col extends ColumnsOf<Table>>( + plaintext: PlaintextForColumn<Col>, + opts: { table: Table; column: Col }, + ): EncryptOperation + + encryptQuery< + Table extends S[number], + Col extends QueryableColumnsOf<Table>, + QT extends QueryTypesForColumn<Col> = QueryTypesForColumn<Col>, + >( + plaintext: PlaintextForColumn<Col>, + opts: { + table: Table + column: Col + queryType?: QT + returnType?: EncryptedReturnType + }, + ): EncryptQueryOperation + + encryptModel<Table extends S[number], T extends Record<string, unknown>>( + input: V3ModelInput<Table, T>, + table: Table, + ): EncryptModelOperation<V3EncryptedModel<Table, T>> + + bulkEncryptModels<Table extends S[number], T extends Record<string, unknown>>( + input: Array<V3ModelInput<Table, T>>, + table: Table, + ): BulkEncryptModelsOperation<V3EncryptedModel<Table, T>> + + /** + * Decrypt a single value. Cannot be strongly typed — a lone ciphertext carries + * no column identity — so it resolves to the FFI plaintext union unchanged. + */ + decrypt(encrypted: Encrypted): DecryptOperation + + /** + * Decrypt a model, returning the precise plaintext shape for `table`. `Date` + * columns are reconstructed from the encrypt-config `cast_as`. + * + * Pass `lockContext` to decrypt identity-bound data — the same context that + * was supplied at encrypt time must be provided here. + * + * Unlike the encrypt operations this returns a plain `Promise<Result<…>>` + * rather than a chainable operation, because it maps the resolved value. + */ + decryptModel<Table extends S[number], T extends Record<string, unknown>>( + input: T, + table: Table, + lockContext?: LockContextInput, + ): Promise<Result<V3DecryptedModel<Table, T>, EncryptionError>> + + bulkDecryptModels<Table extends S[number], T extends Record<string, unknown>>( + input: Array<T>, + table: Table, + lockContext?: LockContextInput, + ): Promise<Result<Array<V3DecryptedModel<Table, T>>, EncryptionError>> + + // Parity passthroughs — not v3-strengthened, delegated as-is. + bulkEncrypt( + plaintexts: BulkEncryptPayload, + opts: EncryptOptions, + ): BulkEncryptOperation + bulkDecrypt(payloads: BulkDecryptPayload): BulkDecryptOperation + getEncryptConfig(): ReturnType<EncryptionClient['getEncryptConfig']> +} + +/** + * Build a per-row reconstructor of `Date` values from the table's + * encrypt-config `cast_as`. The FFI returns `JsPlaintext` + * (string/number/boolean/…) with no `Date`, so those columns arrive as their + * serialized form and are rebuilt here. Safe (idempotent) if the FFI ever + * returns `Date` directly: `new Date(date)` is a no-op. + * + * A factory rather than a `(row, table)` function so the table config — + * row-invariant, but non-trivial to build — is derived once per call site, + * not once per row on the bulk path. + * + * NOTE: `bigint` reconstruction is intentionally absent — bigint domains are + * omitted from the v3 SDK until the native FFI supports lossless bigint I/O. + */ +function rowReconstructor( + table: AnyV3Table, +): (row: Record<string, unknown>) => Record<string, unknown> { + // The decrypted row is keyed by JS property name, but `cast_as` lives on the + // config keyed by DB name — bridge the two via the table's property→DB map. + const { columns } = table.build() + const propToDb = table.buildColumnKeyMap() + // Only date/timestamp columns need per-row work; resolve them up front. + // Both kinds decrypt to a JS `Date` — 'timestamp' additionally preserves + // the time-of-day component through the FFI. + const dateProperties = Object.entries(propToDb) + .filter(([, dbName]) => { + const castAs = columns[dbName]?.cast_as + return castAs === 'date' || castAs === 'timestamp' + }) + .map(([property]) => property) + + return (row) => { + const out: Record<string, unknown> = { ...row } + for (const property of dateProperties) { + const value = out[property] + if (value == null) continue + out[property] = new Date(value as string | number | Date) + } + return out + } +} + +/** + * Wrap an already-built {@link EncryptionClient} in a {@link TypedEncryptionClient} + * for the given v3 schemas. Zero runtime cost for the encrypt/query paths (the + * underlying operations are returned unchanged); the decrypt-model paths add a + * per-column `Date` reconstruction step. + * + * The `schemas` are captured with a `const` type parameter so array-literal + * widening does not collapse per-table inference. + */ +export function typedClient<const S extends readonly AnyV3Table[]>( + client: EncryptionClient, + ..._schemas: S +): TypedEncryptionClient<S> { + return { + encrypt: (plaintext, opts) => + client.encrypt(plaintext as never, opts as never), + encryptQuery: (plaintext, opts) => + client.encryptQuery(plaintext as never, opts as never), + encryptModel: (input, table) => + client.encryptModel(input as never, table as never) as never, + bulkEncryptModels: (input, table) => + client.bulkEncryptModels(input as never, table as never) as never, + decrypt: (encrypted) => client.decrypt(encrypted), + decryptModel: async (input, table, lockContext) => { + const op = client.decryptModel(input as never) + const result = await (lockContext ? op.withLockContext(lockContext) : op) + if (result.failure) return result as never + return { data: rowReconstructor(table)(result.data) } as never + }, + bulkDecryptModels: async (input, table, lockContext) => { + const op = client.bulkDecryptModels(input as never) + const result = await (lockContext ? op.withLockContext(lockContext) : op) + if (result.failure) return result as never + const reconstruct = rowReconstructor(table) + return { + data: result.data.map((row) => + reconstruct(row as Record<string, unknown>), + ), + } as never + }, + bulkEncrypt: (plaintexts, opts) => client.bulkEncrypt(plaintexts, opts), + bulkDecrypt: (payloads) => client.bulkDecrypt(payloads), + getEncryptConfig: () => client.getEncryptConfig(), + } satisfies TypedEncryptionClient<S> +} + +/** + * Build a {@link TypedEncryptionClient} for EQL v3 schemas — the strongly-typed + * counterpart to {@link Encryption}. Mirrors its config, then retypes the client + * against the provided v3 `schemas`. + * + * The underlying client is created with `eqlVersion: 3` (protect-ffi 0.27+), + * so `encrypt` / `encryptModel` emit EQL v3 wire payloads for the + * per-capability `eql_v3` domains. Pass an explicit `config.eqlVersion` to + * override — e.g. `2` to write v2-wire from a v3 schema set during a + * migration. + * + * @example + * ```typescript + * import { EncryptionV3, encryptedTable, types } from "@cipherstash/stack/v3" + * + * const users = encryptedTable("users", { email: types.TextSearch("email") }) + * const client = await EncryptionV3({ schemas: [users] }) + * + * await client.encrypt("a@b.com", { table: users, column: users.email }) + * ``` + */ +export async function EncryptionV3< + const S extends readonly AnyV3Table[], +>(config: { + schemas: S + config?: ClientConfig +}): Promise<TypedEncryptionClient<S>> { + const client = await Encryption({ + schemas: config.schemas as unknown as Parameters< + typeof Encryption + >[0]['schemas'], + // v3 schemas emit the EQL v3 wire format. Auto-detection in + // `Encryption` would resolve the same way (every v3 table carries the + // `buildColumnKeyMap` marker), but the version is set explicitly here + // so the contract doesn't hinge on duck-typing — while still honouring + // a caller's explicit override. + config: { ...config.config, eqlVersion: config.config?.eqlVersion ?? 3 }, + }) + return typedClient(client, ...config.schemas) +} + +// Single import surface: re-export the v3 `types` namespace + table API + type +// helpers so `@cipherstash/stack/v3` provides everything needed to author and +// use a schema. +export * from '@/eql/v3' diff --git a/packages/stack/src/eql/v3/columns.ts b/packages/stack/src/eql/v3/columns.ts new file mode 100644 index 00000000..34855ad3 --- /dev/null +++ b/packages/stack/src/eql/v3/columns.ts @@ -0,0 +1,672 @@ +import type { ColumnSchema, MatchIndexOpts } from '@/schema' +import { + type BuiltMatchIndexOpts, + cloneMatchOpts, + defaultMatchOpts, +} from '@/schema/match-defaults' + +/** + * The query capabilities a v3 concrete domain exposes. These are SDK-facing + * semantic flags describing what kinds of query terms a column can produce — + * NOT the raw EQL index keys. They are metadata only and never emitted by + * `build()`. + * + * - `equality`: exact-match lookups (EQL `hm`, or comparison via `ob`). + * - `orderAndRange`: comparison / range lookups (EQL `ob`). + * - `freeTextSearch`: tokenised substring match (EQL `bf`). + */ +export type QueryCapabilities = Readonly<{ + equality: boolean + orderAndRange: boolean + freeTextSearch: boolean +}> + +/** The plaintext (TypeScript) kind a v3 domain decrypts to. A subset of the + * SDK `CastAs` enum, restricted to the scalar kinds v3 domains actually use. */ +type PlaintextKind = 'string' | 'number' | 'boolean' | 'date' | 'timestamp' + +/** + * The full, literal definition of a v3 domain. This is the LOAD-BEARING type: + * the base column class carries a private field of this type so that every + * concrete (otherwise-empty) subclass is discriminated by its literal + * `eqlType`/`castAs`/`capabilities` — TypeScript empty subclasses are NOT + * nominal, so without this a storage-only `boolean` column would be assignable to + * a storage-only `date` column and plaintext inference would collapse. + */ +type V3DomainDefinition = Readonly<{ + eqlType: `eql_v3.${string}` + castAs: PlaintextKind + capabilities: QueryCapabilities +}> + +/** Type-level mirror of {@link isQueryableCapabilities}: `false` for a + * storage-only domain (all capability flags `false`), `true` otherwise. */ +type QueryableFlag<D extends V3DomainDefinition> = D['capabilities'] extends { + equality: false + orderAndRange: false + freeTextSearch: false +} + ? false + : true + +const STORAGE_ONLY = { + equality: false, + orderAndRange: false, + freeTextSearch: false, +} as const + +const EQUALITY_ONLY = { + equality: true, + orderAndRange: false, + freeTextSearch: false, +} as const + +const ORDER_AND_RANGE = { + equality: true, + orderAndRange: true, + freeTextSearch: false, +} as const + +const MATCH_ONLY = { + equality: false, + orderAndRange: false, + freeTextSearch: true, +} as const + +const TEXT_SEARCH = { + equality: true, + orderAndRange: true, + freeTextSearch: true, +} as const + +/** + * The concrete EQL v3 domain name for a full-capability text column. + * Recorded as metadata for future DDL / query-dialect increments; it is + * intentionally absent from the emitted encrypt config. + */ +export const TEXT_SEARCH_EQL_TYPE = 'eql_v3.text_search' + +// Per-domain literal definitions. Each concrete column subclass is parameterised +// by `typeof <CONST>`; the literal `eqlType`/`castAs`/`capabilities` on each is +// what makes the otherwise-empty subclasses nominally distinct (see +// V3DomainDefinition). Order mirrors eql-bindings `CATALOG` order. +// +// Exported for the `types` namespace factory (see ./types); they are internal +// building blocks and are intentionally NOT re-exported from the public barrel. +export const INTEGER = { + eqlType: 'eql_v3.integer', + castAs: 'number', + capabilities: STORAGE_ONLY, +} as const +export const INTEGER_EQ = { + eqlType: 'eql_v3.integer_eq', + castAs: 'number', + capabilities: EQUALITY_ONLY, +} as const +export const INTEGER_ORD_ORE = { + eqlType: 'eql_v3.integer_ord_ore', + castAs: 'number', + capabilities: ORDER_AND_RANGE, +} as const +export const INTEGER_ORD = { + eqlType: 'eql_v3.integer_ord', + castAs: 'number', + capabilities: ORDER_AND_RANGE, +} as const + +export const SMALLINT = { + eqlType: 'eql_v3.smallint', + castAs: 'number', + capabilities: STORAGE_ONLY, +} as const +export const SMALLINT_EQ = { + eqlType: 'eql_v3.smallint_eq', + castAs: 'number', + capabilities: EQUALITY_ONLY, +} as const +export const SMALLINT_ORD_ORE = { + eqlType: 'eql_v3.smallint_ord_ore', + castAs: 'number', + capabilities: ORDER_AND_RANGE, +} as const +export const SMALLINT_ORD = { + eqlType: 'eql_v3.smallint_ord', + castAs: 'number', + capabilities: ORDER_AND_RANGE, +} as const + +// NOTE: bigint (int8) domains are intentionally NOT defined yet. The native +// protect-ffi build cannot round-trip a 64-bit int losslessly: a JS `bigint` +// fails JSON serialization, and a `string` is rejected for a `big_int` column +// ("Cannot convert String to BigInt"), while `number` loses precision above +// 2^53. Re-add BIGINT/BIGINT_EQ/BIGINT_ORD_ORE/BIGINT_ORD and their builders once the +// FFI accepts a lossless bigint on input and returns it on decrypt. + +export const DATE = { + eqlType: 'eql_v3.date', + castAs: 'date', + capabilities: STORAGE_ONLY, +} as const +export const DATE_EQ = { + eqlType: 'eql_v3.date_eq', + castAs: 'date', + capabilities: EQUALITY_ONLY, +} as const +export const DATE_ORD_ORE = { + eqlType: 'eql_v3.date_ord_ore', + castAs: 'date', + capabilities: ORDER_AND_RANGE, +} as const +export const DATE_ORD = { + eqlType: 'eql_v3.date_ord', + castAs: 'date', + capabilities: ORDER_AND_RANGE, +} as const + +// Timestamp domains cast as 'timestamp' (not 'date') so decrypt preserves the +// time-of-day component — the FFI's 'date' variant truncates to midnight. +// Both kinds decrypt to a JS `Date`. +export const TIMESTAMP = { + eqlType: 'eql_v3.timestamp', + castAs: 'timestamp', + capabilities: STORAGE_ONLY, +} as const +export const TIMESTAMP_EQ = { + eqlType: 'eql_v3.timestamp_eq', + castAs: 'timestamp', + capabilities: EQUALITY_ONLY, +} as const +export const TIMESTAMP_ORD_ORE = { + eqlType: 'eql_v3.timestamp_ord_ore', + castAs: 'timestamp', + capabilities: ORDER_AND_RANGE, +} as const +export const TIMESTAMP_ORD = { + eqlType: 'eql_v3.timestamp_ord', + castAs: 'timestamp', + capabilities: ORDER_AND_RANGE, +} as const + +export const NUMERIC = { + eqlType: 'eql_v3.numeric', + castAs: 'number', + capabilities: STORAGE_ONLY, +} as const +export const NUMERIC_EQ = { + eqlType: 'eql_v3.numeric_eq', + castAs: 'number', + capabilities: EQUALITY_ONLY, +} as const +export const NUMERIC_ORD_ORE = { + eqlType: 'eql_v3.numeric_ord_ore', + castAs: 'number', + capabilities: ORDER_AND_RANGE, +} as const +export const NUMERIC_ORD = { + eqlType: 'eql_v3.numeric_ord', + castAs: 'number', + capabilities: ORDER_AND_RANGE, +} as const + +export const TEXT = { + eqlType: 'eql_v3.text', + castAs: 'string', + capabilities: STORAGE_ONLY, +} as const +export const TEXT_EQ = { + eqlType: 'eql_v3.text_eq', + castAs: 'string', + capabilities: EQUALITY_ONLY, +} as const +export const TEXT_MATCH = { + eqlType: 'eql_v3.text_match', + castAs: 'string', + capabilities: MATCH_ONLY, +} as const +export const TEXT_ORD_ORE = { + eqlType: 'eql_v3.text_ord_ore', + castAs: 'string', + capabilities: ORDER_AND_RANGE, +} as const +export const TEXT_ORD = { + eqlType: 'eql_v3.text_ord', + castAs: 'string', + capabilities: ORDER_AND_RANGE, +} as const + +export const BOOLEAN = { + eqlType: 'eql_v3.boolean', + castAs: 'boolean', + capabilities: STORAGE_ONLY, +} as const + +export const REAL = { + eqlType: 'eql_v3.real', + castAs: 'number', + capabilities: STORAGE_ONLY, +} as const +export const REAL_EQ = { + eqlType: 'eql_v3.real_eq', + castAs: 'number', + capabilities: EQUALITY_ONLY, +} as const +export const REAL_ORD_ORE = { + eqlType: 'eql_v3.real_ord_ore', + castAs: 'number', + capabilities: ORDER_AND_RANGE, +} as const +export const REAL_ORD = { + eqlType: 'eql_v3.real_ord', + castAs: 'number', + capabilities: ORDER_AND_RANGE, +} as const + +export const DOUBLE = { + eqlType: 'eql_v3.double', + castAs: 'number', + capabilities: STORAGE_ONLY, +} as const +export const DOUBLE_EQ = { + eqlType: 'eql_v3.double_eq', + castAs: 'number', + capabilities: EQUALITY_ONLY, +} as const +export const DOUBLE_ORD_ORE = { + eqlType: 'eql_v3.double_ord_ore', + castAs: 'number', + capabilities: ORDER_AND_RANGE, +} as const +export const DOUBLE_ORD = { + eqlType: 'eql_v3.double_ord', + castAs: 'number', + capabilities: ORDER_AND_RANGE, +} as const + +/** + * Translate a domain's semantic {@link QueryCapabilities} (plus its plaintext + * `castAs`, which decides how equality is answered) into the concrete EQL index + * block emitted by `build()`. + * + * - `unique` (the `hm` HMAC index) whenever equality is answered via HMAC: + * equality-only domains of ANY type, AND text order domains. Text equality is + * HMAC-based — the `eql_v3.text_ord` / `eql_v3.text_ord_ore` SQL domains + * REQUIRE `hm` in the stored ciphertext (their `eql_v3.eq_term` extracts it). + * - `ore` for any order/range domain (the `ob` term). For numeric/date order + * domains `ob` also answers equality (via the SQL `=` operator), so those emit + * `ore` ONLY — no `hm`. Text order domains emit BOTH `unique` and `ore`. + * - `match` (the `bf` bloom-filter index) for free-text search, deep-cloned from + * the per-call defaults so no nested object is ever shared across columns. + */ +function indexesForCapabilities( + capabilities: QueryCapabilities, + castAs: PlaintextKind, +): ColumnSchema['indexes'] { + const indexes: ColumnSchema['indexes'] = {} + + // Text equality is always HMAC-based, so a text order domain (`string` + + // order/range) still needs `unique`; numeric/date order domains answer + // equality via `ob` and must NOT emit `unique`. + if ( + capabilities.equality && + (!capabilities.orderAndRange || castAs === 'string') + ) { + indexes.unique = { token_filters: [] } + } + + if (capabilities.orderAndRange) { + indexes.ore = {} + } + + if (capabilities.freeTextSearch) { + // The factory returns fresh, unaliased nested objects per call, so no + // column's emitted match block ever shares state with another's. + indexes.match = defaultMatchOpts() + } + + return indexes +} + +/** Whether a domain's capabilities make it queryable at all (any flag set). */ +function isQueryableCapabilities(capabilities: QueryCapabilities): boolean { + return ( + capabilities.equality || + capabilities.orderAndRange || + capabilities.freeTextSearch + ) +} + +/** + * Shared base for every v3 concrete domain column. Parameterised by the FULL + * literal {@link V3DomainDefinition} (not by capabilities alone): the private + * `definition` field carries the literal `eqlType`/`castAs`/`capabilities`, so + * two otherwise-empty subclasses (e.g. `EncryptedBooleanColumn` and + * `EncryptedDateColumn`, both storage-only) are NOT mutually assignable. This + * nominality is what keeps plaintext inference precise. + */ +export class EncryptedV3Column<D extends V3DomainDefinition> { + constructor( + private readonly columnName: string, + private readonly definition: D, + ) {} + + getName(): string { + return this.columnName + } + + /** The concrete EQL v3 domain name. Metadata only; not emitted by `build()`. */ + getEqlType(): D['eqlType'] { + return this.definition.eqlType + } + + /** The semantic query capabilities this domain exposes. Metadata only. */ + getQueryCapabilities(): D['capabilities'] { + return this.definition.capabilities + } + + /** `true` when this domain can produce at least one kind of query term. */ + isQueryable(): QueryableFlag<D> { + return isQueryableCapabilities( + this.definition.capabilities, + ) as QueryableFlag<D> + } + + /** Emit the encrypt-config column: `cast_as` plus capability-derived indexes. */ + build(): ColumnSchema { + return { + cast_as: this.definition.castAs, + indexes: indexesForCapabilities( + this.definition.capabilities, + this.definition.castAs, + ), + } + } +} + +const TEXT_SEARCH_DOMAIN = { + eqlType: TEXT_SEARCH_EQL_TYPE, + castAs: 'string', + capabilities: TEXT_SEARCH, +} as const + +/** + * Builder for an `eql_v3.text_search` column. + * + * The concrete type inherently enables equality + order/range + free-text + * match — there are no capability-enabling methods. `.freeTextSearch(opts?)` + * tunes the match index only. + * + * NOTE — querying: a `text_search` column emits all three indexes (`unique`, + * `ore`, `match`), and the shared index-inference picks them by fixed priority + * `unique > match > ore`. So `encryptQuery(value, { column, table })` with NO + * explicit `queryType` builds an EQUALITY term (via `unique`), NOT a free-text + * match — a substring like `'joh'` then matches nothing. To run a free-text + * match query you MUST pass `queryType: 'freeTextSearch'`: + * + * ```typescript + * // equality (default): exact value only + * client.encryptQuery('john@example.com', { column: users.email, table: users }) + * // free-text match: substring/token search + * client.encryptQuery('joh', { column: users.email, table: users, queryType: 'freeTextSearch' }) + * ``` + */ +export class EncryptedTextSearchColumn extends EncryptedV3Column< + typeof TEXT_SEARCH_DOMAIN +> { + private matchOpts: BuiltMatchIndexOpts + + constructor(columnName: string) { + super(columnName, TEXT_SEARCH_DOMAIN) + this.matchOpts = defaultMatchOpts() + } + + /** + * Tune the match index. Each provided key replaces its default; omitted + * keys keep the default. This NEVER enables a capability — match is always + * on for this type. Merge semantics mirror v2's `opts?.x ?? default`. + */ + freeTextSearch(opts?: MatchIndexOpts): this { + // A fresh defaults object per call supplies the `?? ` fallbacks, so no + // nested default object is ever shared into `this.matchOpts` by reference. + const defaults = defaultMatchOpts() + // Clone-on-write: deep-copy the nested tokenizer / token_filters when + // storing them so a caller mutating their own opts object between + // freeTextSearch(opts) and build() cannot leak into the emitted config. + this.matchOpts = cloneMatchOpts({ + tokenizer: opts?.tokenizer ?? defaults.tokenizer, + token_filters: opts?.token_filters ?? defaults.token_filters, + k: opts?.k ?? defaults.k, + m: opts?.m ?? defaults.m, + include_original: opts?.include_original ?? defaults.include_original, + }) + return this + } + + /** Emit the encrypt-config column. Byte-identical to a v2 equality+order+match column. */ + override build(): ColumnSchema { + // Deep-clone the match block so the returned config NEVER aliases this + // builder's internal `matchOpts` (or any caller-supplied opts merged into + // it). A caller mutating the returned object cannot corrupt this builder's + // state or another column's defaults. + return { + cast_as: 'string', + indexes: { + unique: { token_filters: [] }, + ore: {}, + match: cloneMatchOpts(this.matchOpts), + }, + } + } +} + +// --------------------------------------------------------------------------- +// Concrete domain columns +// +// Every concrete class is an empty subclass parameterised by its literal domain +// definition (see EncryptedV3Column). The `types` namespace (see ./types) +// constructs these with the SAME literal constant so the instance's private +// `definition` field carries full literal type data — that is what keeps +// distinct domains nominally incompatible. +// --------------------------------------------------------------------------- + +// integer +export class EncryptedIntegerColumn extends EncryptedV3Column<typeof INTEGER> {} +export class EncryptedIntegerEqColumn extends EncryptedV3Column< + typeof INTEGER_EQ +> {} +export class EncryptedIntegerOrdOreColumn extends EncryptedV3Column< + typeof INTEGER_ORD_ORE +> {} +export class EncryptedIntegerOrdColumn extends EncryptedV3Column< + typeof INTEGER_ORD +> {} + +// smallint +export class EncryptedSmallintColumn extends EncryptedV3Column< + typeof SMALLINT +> {} +export class EncryptedSmallintEqColumn extends EncryptedV3Column< + typeof SMALLINT_EQ +> {} +export class EncryptedSmallintOrdOreColumn extends EncryptedV3Column< + typeof SMALLINT_ORD_ORE +> {} +export class EncryptedSmallintOrdColumn extends EncryptedV3Column< + typeof SMALLINT_ORD +> {} + +// bigint (int8) domain builders are intentionally omitted pending FFI support +// for lossless bigint round-tripping — see the note by the INTEGER/DATE domain +// definitions above. + +// date +export class EncryptedDateColumn extends EncryptedV3Column<typeof DATE> {} +export class EncryptedDateEqColumn extends EncryptedV3Column<typeof DATE_EQ> {} +export class EncryptedDateOrdOreColumn extends EncryptedV3Column< + typeof DATE_ORD_ORE +> {} +export class EncryptedDateOrdColumn extends EncryptedV3Column< + typeof DATE_ORD +> {} + +// timestamp +export class EncryptedTimestampColumn extends EncryptedV3Column< + typeof TIMESTAMP +> {} +export class EncryptedTimestampEqColumn extends EncryptedV3Column< + typeof TIMESTAMP_EQ +> {} +export class EncryptedTimestampOrdOreColumn extends EncryptedV3Column< + typeof TIMESTAMP_ORD_ORE +> {} +export class EncryptedTimestampOrdColumn extends EncryptedV3Column< + typeof TIMESTAMP_ORD +> {} + +// numeric +export class EncryptedNumericColumn extends EncryptedV3Column<typeof NUMERIC> {} +export class EncryptedNumericEqColumn extends EncryptedV3Column< + typeof NUMERIC_EQ +> {} +export class EncryptedNumericOrdOreColumn extends EncryptedV3Column< + typeof NUMERIC_ORD_ORE +> {} +export class EncryptedNumericOrdColumn extends EncryptedV3Column< + typeof NUMERIC_ORD +> {} + +// text (text_search is defined above with its match-tuning override) +export class EncryptedTextColumn extends EncryptedV3Column<typeof TEXT> {} +export class EncryptedTextEqColumn extends EncryptedV3Column<typeof TEXT_EQ> {} +export class EncryptedTextMatchColumn extends EncryptedV3Column< + typeof TEXT_MATCH +> {} +export class EncryptedTextOrdOreColumn extends EncryptedV3Column< + typeof TEXT_ORD_ORE +> {} +export class EncryptedTextOrdColumn extends EncryptedV3Column< + typeof TEXT_ORD +> {} + +// boolean +export class EncryptedBooleanColumn extends EncryptedV3Column<typeof BOOLEAN> {} + +// real +export class EncryptedRealColumn extends EncryptedV3Column<typeof REAL> {} +export class EncryptedRealEqColumn extends EncryptedV3Column<typeof REAL_EQ> {} +export class EncryptedRealOrdOreColumn extends EncryptedV3Column< + typeof REAL_ORD_ORE +> {} +export class EncryptedRealOrdColumn extends EncryptedV3Column< + typeof REAL_ORD +> {} + +// double +export class EncryptedDoubleColumn extends EncryptedV3Column<typeof DOUBLE> {} +export class EncryptedDoubleEqColumn extends EncryptedV3Column< + typeof DOUBLE_EQ +> {} +export class EncryptedDoubleOrdOreColumn extends EncryptedV3Column< + typeof DOUBLE_ORD_ORE +> {} +export class EncryptedDoubleOrdColumn extends EncryptedV3Column< + typeof DOUBLE_ORD +> {} + +/** + * Union of every v3 concrete column type. Used as the value type for v3 table + * columns so a table may mix any generated domains. + */ +export type AnyEncryptedV3Column = + | EncryptedIntegerColumn + | EncryptedIntegerEqColumn + | EncryptedIntegerOrdOreColumn + | EncryptedIntegerOrdColumn + | EncryptedSmallintColumn + | EncryptedSmallintEqColumn + | EncryptedSmallintOrdOreColumn + | EncryptedSmallintOrdColumn + | EncryptedDateColumn + | EncryptedDateEqColumn + | EncryptedDateOrdOreColumn + | EncryptedDateOrdColumn + | EncryptedTimestampColumn + | EncryptedTimestampEqColumn + | EncryptedTimestampOrdOreColumn + | EncryptedTimestampOrdColumn + | EncryptedNumericColumn + | EncryptedNumericEqColumn + | EncryptedNumericOrdOreColumn + | EncryptedNumericOrdColumn + | EncryptedTextColumn + | EncryptedTextEqColumn + | EncryptedTextMatchColumn + | EncryptedTextOrdOreColumn + | EncryptedTextOrdColumn + | EncryptedTextSearchColumn + | EncryptedBooleanColumn + | EncryptedRealColumn + | EncryptedRealEqColumn + | EncryptedRealOrdOreColumn + | EncryptedRealOrdColumn + | EncryptedDoubleColumn + | EncryptedDoubleEqColumn + | EncryptedDoubleOrdOreColumn + | EncryptedDoubleOrdColumn + +/** + * Shape of v3 table columns: every value is a v3 concrete column builder. + * (Nested fields are deferred to later increments.) + */ +export type EncryptedV3TableColumn = { + [key: string]: AnyEncryptedV3Column +} + +/** Map a domain's {@link PlaintextKind} to its TypeScript plaintext type. */ +type PlaintextFromKind<K extends PlaintextKind> = K extends 'string' + ? string + : K extends 'number' + ? number + : K extends 'boolean' + ? boolean + : K extends 'date' | 'timestamp' + ? Date + : never + +/** + * The plaintext type for a single v3 column, read from the literal domain + * definition carried on the base class's private field. This is stable across + * empty subclasses that share the same base generic — a subclass-name + * conditional would collapse because those subclasses are structurally + * assignable to one another. + */ +export type PlaintextForColumn<C> = + C extends EncryptedV3Column<infer D> ? PlaintextFromKind<D['castAs']> : never + +/** + * The user-facing `queryType` names a v3 column supports, derived 1:1 from its + * capability flags. Resolves to `never` for a storage-only column (all flags + * `false`) and for any non-v3 value. The names mirror the {@link QueryCapabilities} + * keys and the first three {@link import('@/types').QueryTypeName} members. + */ +export type QueryTypesForColumn<C> = + C extends EncryptedV3Column<infer D> + ? + | (D['capabilities']['equality'] extends true ? 'equality' : never) + | (D['capabilities']['orderAndRange'] extends true + ? 'orderAndRange' + : never) + | (D['capabilities']['freeTextSearch'] extends true + ? 'freeTextSearch' + : never) + : never + +/** + * The concrete EQL v3 type string for a single column, read from the literal + * domain definition carried on the base class's private field (mirrors + * {@link PlaintextForColumn}). Distributes over a union of columns, so + * `EqlTypeForColumn<AnyEncryptedV3Column>` yields the union of every domain's + * `eqlType` — the canonical, source-of-truth key set for a type-driven test + * matrix keyed by domain. + */ +export type EqlTypeForColumn<C> = + C extends EncryptedV3Column<infer D> ? D['eqlType'] : never diff --git a/packages/stack/src/eql/v3/index.ts b/packages/stack/src/eql/v3/index.ts new file mode 100644 index 00000000..3889f1f2 --- /dev/null +++ b/packages/stack/src/eql/v3/index.ts @@ -0,0 +1,70 @@ +// Public barrel for the EQL v3 authoring DSL (`@cipherstash/stack/eql/v3`). +// +// Curated on purpose: it re-exports the `types` namespace, the concrete column +// classes (load-bearing for the `AnyEncryptedV3Column` union and nominal +// typing), the table API, and the inference type aliases. It deliberately does +// NOT re-export the per-domain literal consts (`INTEGER`, `TEXT_EQ`, …) — those are +// internal building blocks for `types` — and there are no standalone +// `encrypted<Domain>Column` factories any more: `types.*` is the single +// authoring API. + +export type { + AnyEncryptedV3Column, + EncryptedV3TableColumn, + EqlTypeForColumn, + PlaintextForColumn, + QueryCapabilities, + QueryTypesForColumn, +} from './columns' + +export { + EncryptedBooleanColumn, + EncryptedDateColumn, + EncryptedDateEqColumn, + EncryptedDateOrdColumn, + EncryptedDateOrdOreColumn, + EncryptedRealColumn, + EncryptedRealEqColumn, + EncryptedRealOrdColumn, + EncryptedRealOrdOreColumn, + EncryptedDoubleColumn, + EncryptedDoubleEqColumn, + EncryptedDoubleOrdColumn, + EncryptedDoubleOrdOreColumn, + EncryptedSmallintColumn, + EncryptedSmallintEqColumn, + EncryptedSmallintOrdColumn, + EncryptedSmallintOrdOreColumn, + EncryptedIntegerColumn, + EncryptedIntegerEqColumn, + EncryptedIntegerOrdColumn, + EncryptedIntegerOrdOreColumn, + EncryptedNumericColumn, + EncryptedNumericEqColumn, + EncryptedNumericOrdColumn, + EncryptedNumericOrdOreColumn, + EncryptedTextColumn, + EncryptedTextEqColumn, + EncryptedTextMatchColumn, + EncryptedTextOrdColumn, + EncryptedTextOrdOreColumn, + EncryptedTextSearchColumn, + EncryptedTimestampColumn, + EncryptedTimestampEqColumn, + EncryptedTimestampOrdColumn, + EncryptedTimestampOrdOreColumn, + TEXT_SEARCH_EQL_TYPE, +} from './columns' +export type { + AnyV3Table, + ColumnsOf, + InferEncrypted, + InferPlaintext, + QueryableColumnsOf, + V3DecryptedModel, + V3EncryptedModel, + V3ModelInput, +} from './table' + +export { buildEncryptConfig, EncryptedTable, encryptedTable } from './table' +export { types } from './types' diff --git a/packages/stack/src/eql/v3/table.ts b/packages/stack/src/eql/v3/table.ts new file mode 100644 index 00000000..c5b3f069 --- /dev/null +++ b/packages/stack/src/eql/v3/table.ts @@ -0,0 +1,221 @@ +import type { ColumnSchema, EncryptConfig } from '@/schema' +import type { Encrypted } from '@/types' +import type { + EncryptedV3TableColumn, + PlaintextForColumn, + QueryTypesForColumn, +} from './columns' + +interface TableDefinition { + tableName: string + columns: Record<string, ColumnSchema> +} + +/** + * A v3 encrypted table. Mirrors the v2 `EncryptedTable` but only accepts v3 + * column builders. Emits the same `{ tableName, columns }` definition shape. + */ +export class EncryptedTable<T extends EncryptedV3TableColumn> { + /** @internal Type-level brand so TypeScript can infer `T` from `EncryptedTable<T>`. */ + declare readonly _columnType: T + + constructor( + public readonly tableName: string, + public readonly columnBuilders: T, + ) {} + + build(): TableDefinition { + const builtColumns: Record<string, ColumnSchema> = {} + for (const builder of Object.values(this.columnBuilders)) { + // Key by the column's DB name (`getName()`), NOT the JS property name. + // `encrypt`/`decrypt` look columns up in the config by `column.getName()`, + // so a camelCase JS key mapping to a snake_case DB column (e.g. + // `createdOn: types.Date('created_on')`) must register under + // `created_on` or the FFI reports "column not found in Encrypt config". + const name = builder.getName() + // Two JS properties resolving to the same DB name would silently overwrite + // here (later wins), dropping the first column's config. Fail loudly — + // matching the duplicate-tableName guard in buildEncryptConfig and the + // reserved-key guard in encryptedTable. + if (Object.hasOwn(builtColumns, name)) { + throw new Error( + `[eql/v3]: duplicate column name "${name}" in table "${this.tableName}" — two columns resolve to the same DB name`, + ) + } + builtColumns[name] = builder.build() + } + return { + tableName: this.tableName, + columns: builtColumns, + } + } + + /** + * Map each column's JS property name to its DB column name (`getName()`). + * The model path matches user models by property name but must address the + * encrypt config and FFI by DB name — `build()` keys columns by DB name, so + * the two only agree when property == name. This recovers the mapping that + * `build()` discards. + */ + buildColumnKeyMap(): Record<string, string> { + const map: Record<string, string> = {} + for (const [property, builder] of Object.entries(this.columnBuilders)) { + map[property] = builder.getName() + } + return map + } +} + +/** + * Own instance members of {@link EncryptedTable} that a column name must not + * shadow. Because {@link encryptedTable} copies column builders onto the + * instance for accessor access (`users.email`), a column named e.g. `build` + * would otherwise overwrite the method that {@link buildEncryptConfig} relies + * on. `_columnType` is a type-only `declare` (no runtime property) so it is + * listed explicitly here rather than caught by the `in` check below. + */ +const RESERVED_TABLE_KEYS = new Set([ + 'tableName', + 'columnBuilders', + '_columnType', + 'build', + 'buildColumnKeyMap', +]) + +/** + * Whether a column name would collide with a reserved property on the table + * object — either an own member ({@link RESERVED_TABLE_KEYS}) or any inherited + * `Object.prototype` member (`constructor`, `toString`, `valueOf`, + * `hasOwnProperty`, …). The `in` check covers the prototype chain so assigning + * the column as an own property can never shadow a prototype method/accessor. + */ +function isReservedTableKey(tableBuilder: object, colName: string): boolean { + return RESERVED_TABLE_KEYS.has(colName) || colName in tableBuilder +} + +/** + * Define a v3 encrypted table. Intentionally shadows the v2 `encryptedTable` + * name but lives on the `/eql/v3` subpath — the importer picks the model by + * import path. The returned object is also a column accessor (`users.email`). + */ +export function encryptedTable<T extends EncryptedV3TableColumn>( + tableName: string, + columns: T, +): EncryptedTable<T> & T { + const tableBuilder = new EncryptedTable( + tableName, + columns, + ) as EncryptedTable<T> & T + + for (const [colName, colBuilder] of Object.entries(columns)) { + if (isReservedTableKey(tableBuilder, colName)) { + throw new Error( + `Column name "${colName}" collides with a reserved EncryptedTable property`, + ) + } + ;(tableBuilder as EncryptedV3TableColumn)[colName] = colBuilder + } + + return tableBuilder +} + +/** + * Build an `EncryptConfig` (`v: 1`) from one or more v3 tables. Emits the same + * shape as v2's `buildEncryptConfig`. + */ +export function buildEncryptConfig( + ...tables: Array<EncryptedTable<EncryptedV3TableColumn>> +): EncryptConfig { + const config: EncryptConfig = { + v: 1, + tables: {}, + } + + for (const tb of tables) { + const tableDef = tb.build() + // Config tables are keyed by name, so a duplicate would silently overwrite + // the earlier table. Fail loudly instead. (v3-only additive guard; v2's + // buildEncryptConfig keeps its existing silent-overwrite behavior.) + if (Object.hasOwn(config.tables, tableDef.tableName)) { + throw new Error( + `[eql/v3]: duplicate table name "${tableDef.tableName}" passed to buildEncryptConfig — each table must have a unique name`, + ) + } + config.tables[tableDef.tableName] = tableDef.columns + } + + return config +} + +/** + * Infer the plaintext (decrypted) shape from a v3 table schema. Each column maps + * to the TypeScript type of its domain's `castAs` kind. + */ +export type InferPlaintext<T extends EncryptedTable<EncryptedV3TableColumn>> = + T extends EncryptedTable<infer C> + ? { [K in keyof C]: PlaintextForColumn<C[K]> } + : never + +/** + * Infer the encrypted shape from a v3 table schema. See {@link InferPlaintext} + * for why no key-remap filter is needed in the flat single-type model. + */ +export type InferEncrypted<T extends EncryptedTable<EncryptedV3TableColumn>> = + T extends EncryptedTable<infer C> ? { [K in keyof C]: Encrypted } : never + +// --------------------------------------------------------------------------- +// Typed-client surface helpers (@cipherstash/stack/v3) +// --------------------------------------------------------------------------- + +/** Any v3 table, regardless of its column map. */ +export type AnyV3Table = EncryptedTable<EncryptedV3TableColumn> + +/** Union of the concrete column builders declared on a v3 table. */ +export type ColumnsOf<T extends AnyV3Table> = + T extends EncryptedTable<infer C> ? C[keyof C] : never + +/** + * Union of the *queryable* column builders on a v3 table. Storage-only columns + * (whose {@link QueryTypesForColumn} is `never`) are filtered out, so they can't + * be passed to a query method. + */ +export type QueryableColumnsOf<T extends AnyV3Table> = + T extends EncryptedTable<infer C> + ? { + [K in keyof C]: [QueryTypesForColumn<C[K]>] extends [never] + ? never + : C[K] + }[keyof C] + : never + +/** + * The accepted input model for {@link import('@/encryption/v3').TypedEncryptionClient.encryptModel}. + * `T` is inferred from the argument: keys that name a schema column are pinned to + * the column's plaintext type (nullable if the field is nullable), so a wrong-typed + * field fails assignability; all other keys pass through unchanged. + */ +export type V3ModelInput<Table extends AnyV3Table, T> = { + [K in keyof T]: K extends keyof InferPlaintext<Table> + ? null extends T[K] + ? InferPlaintext<Table>[K] | null + : InferPlaintext<Table>[K] + : T[K] +} + +/** The encrypted result model: schema columns become `Encrypted`, others pass through. */ +export type V3EncryptedModel<Table extends AnyV3Table, T> = { + [K in keyof T]: K extends keyof InferPlaintext<Table> + ? null extends T[K] + ? Encrypted | null + : Encrypted + : T[K] +} + +/** The decrypted result model: schema columns become their plaintext type, others pass through. */ +export type V3DecryptedModel<Table extends AnyV3Table, T> = { + [K in keyof T]: K extends keyof InferPlaintext<Table> + ? null extends T[K] + ? InferPlaintext<Table>[K] | null + : InferPlaintext<Table>[K] + : T[K] +} diff --git a/packages/stack/src/eql/v3/types.ts b/packages/stack/src/eql/v3/types.ts new file mode 100644 index 00000000..df2d55e4 --- /dev/null +++ b/packages/stack/src/eql/v3/types.ts @@ -0,0 +1,166 @@ +import { + BOOLEAN, + DATE, + DATE_EQ, + DATE_ORD, + DATE_ORD_ORE, + EncryptedBooleanColumn, + EncryptedDateColumn, + EncryptedDateEqColumn, + EncryptedDateOrdColumn, + EncryptedDateOrdOreColumn, + EncryptedRealColumn, + EncryptedRealEqColumn, + EncryptedRealOrdColumn, + EncryptedRealOrdOreColumn, + EncryptedDoubleColumn, + EncryptedDoubleEqColumn, + EncryptedDoubleOrdColumn, + EncryptedDoubleOrdOreColumn, + EncryptedSmallintColumn, + EncryptedSmallintEqColumn, + EncryptedSmallintOrdColumn, + EncryptedSmallintOrdOreColumn, + EncryptedIntegerColumn, + EncryptedIntegerEqColumn, + EncryptedIntegerOrdColumn, + EncryptedIntegerOrdOreColumn, + EncryptedNumericColumn, + EncryptedNumericEqColumn, + EncryptedNumericOrdColumn, + EncryptedNumericOrdOreColumn, + EncryptedTextColumn, + EncryptedTextEqColumn, + EncryptedTextMatchColumn, + EncryptedTextOrdColumn, + EncryptedTextOrdOreColumn, + EncryptedTextSearchColumn, + EncryptedTimestampColumn, + EncryptedTimestampEqColumn, + EncryptedTimestampOrdColumn, + EncryptedTimestampOrdOreColumn, + REAL, + REAL_EQ, + REAL_ORD, + REAL_ORD_ORE, + DOUBLE, + DOUBLE_EQ, + DOUBLE_ORD, + DOUBLE_ORD_ORE, + SMALLINT, + SMALLINT_EQ, + SMALLINT_ORD, + SMALLINT_ORD_ORE, + INTEGER, + INTEGER_EQ, + INTEGER_ORD, + INTEGER_ORD_ORE, + NUMERIC, + NUMERIC_EQ, + NUMERIC_ORD, + NUMERIC_ORD_ORE, + TEXT, + TEXT_EQ, + TEXT_MATCH, + TEXT_ORD, + TEXT_ORD_ORE, + TIMESTAMP, + TIMESTAMP_EQ, + TIMESTAMP_ORD, + TIMESTAMP_ORD_ORE, +} from './columns' + +/** + * The v3 column-type namespace. Each member is a factory that builds a concrete + * EQL v3 column; the member name mirrors the underlying `eql_v3.<name>` domain + * (strip the `eql_v3.` prefix, PascalCase each `_`-separated segment). So + * `types.TextEq('actor')` builds an `eql_v3.text_eq` column, `types.IntegerOrd` + * an `eql_v3.integer_ord`, `types.Timestamp` an `eql_v3.timestamp`, and so on. + * + * Each factory returns the CONCRETE column class instance (never the widened + * `AnyEncryptedV3Column`) so per-column plaintext / query-capability inference + * stays precise. + * + * ```ts + * import { encryptedTable, types } from '@cipherstash/stack/eql/v3' + * + * const events = encryptedTable('events', { + * actor: types.TextEq('actor'), // equality + * weight: types.IntegerOrd('weight'), // order + range + * createdAt: types.Timestamp('created_at'), // storage only + * }) + * ``` + * + * `types.TextSearch` keeps the chainable `.freeTextSearch(opts)` tuner (the + * only capability-bearing chain — every other domain is fully described by its + * type). bigint domains are intentionally absent pending lossless FFI + * round-tripping (see ./columns). + */ +export const types = { + // integer + Integer: (name: string) => new EncryptedIntegerColumn(name, INTEGER), + IntegerEq: (name: string) => new EncryptedIntegerEqColumn(name, INTEGER_EQ), + IntegerOrdOre: (name: string) => + new EncryptedIntegerOrdOreColumn(name, INTEGER_ORD_ORE), + IntegerOrd: (name: string) => + new EncryptedIntegerOrdColumn(name, INTEGER_ORD), + + // smallint + Smallint: (name: string) => new EncryptedSmallintColumn(name, SMALLINT), + SmallintEq: (name: string) => + new EncryptedSmallintEqColumn(name, SMALLINT_EQ), + SmallintOrdOre: (name: string) => + new EncryptedSmallintOrdOreColumn(name, SMALLINT_ORD_ORE), + SmallintOrd: (name: string) => + new EncryptedSmallintOrdColumn(name, SMALLINT_ORD), + + // date + Date: (name: string) => new EncryptedDateColumn(name, DATE), + DateEq: (name: string) => new EncryptedDateEqColumn(name, DATE_EQ), + DateOrdOre: (name: string) => + new EncryptedDateOrdOreColumn(name, DATE_ORD_ORE), + DateOrd: (name: string) => new EncryptedDateOrdColumn(name, DATE_ORD), + + // timestamp + Timestamp: (name: string) => new EncryptedTimestampColumn(name, TIMESTAMP), + TimestampEq: (name: string) => + new EncryptedTimestampEqColumn(name, TIMESTAMP_EQ), + TimestampOrdOre: (name: string) => + new EncryptedTimestampOrdOreColumn(name, TIMESTAMP_ORD_ORE), + TimestampOrd: (name: string) => + new EncryptedTimestampOrdColumn(name, TIMESTAMP_ORD), + + // numeric + Numeric: (name: string) => new EncryptedNumericColumn(name, NUMERIC), + NumericEq: (name: string) => new EncryptedNumericEqColumn(name, NUMERIC_EQ), + NumericOrdOre: (name: string) => + new EncryptedNumericOrdOreColumn(name, NUMERIC_ORD_ORE), + NumericOrd: (name: string) => + new EncryptedNumericOrdColumn(name, NUMERIC_ORD), + + // text + Text: (name: string) => new EncryptedTextColumn(name, TEXT), + TextEq: (name: string) => new EncryptedTextEqColumn(name, TEXT_EQ), + TextMatch: (name: string) => new EncryptedTextMatchColumn(name, TEXT_MATCH), + TextOrdOre: (name: string) => + new EncryptedTextOrdOreColumn(name, TEXT_ORD_ORE), + TextOrd: (name: string) => new EncryptedTextOrdColumn(name, TEXT_ORD), + TextSearch: (name: string) => new EncryptedTextSearchColumn(name), + + // boolean + Boolean: (name: string) => new EncryptedBooleanColumn(name, BOOLEAN), + + // real + Real: (name: string) => new EncryptedRealColumn(name, REAL), + RealEq: (name: string) => new EncryptedRealEqColumn(name, REAL_EQ), + RealOrdOre: (name: string) => + new EncryptedRealOrdOreColumn(name, REAL_ORD_ORE), + RealOrd: (name: string) => new EncryptedRealOrdColumn(name, REAL_ORD), + + // double + Double: (name: string) => new EncryptedDoubleColumn(name, DOUBLE), + DoubleEq: (name: string) => new EncryptedDoubleEqColumn(name, DOUBLE_EQ), + DoubleOrdOre: (name: string) => + new EncryptedDoubleOrdOreColumn(name, DOUBLE_ORD_ORE), + DoubleOrd: (name: string) => new EncryptedDoubleOrdColumn(name, DOUBLE_ORD), +} as const diff --git a/packages/stack/src/identity/index.ts b/packages/stack/src/identity/index.ts index a1197321..f9d0e4fb 100644 --- a/packages/stack/src/identity/index.ts +++ b/packages/stack/src/identity/index.ts @@ -39,7 +39,12 @@ export type LockContextInput = LockContext | Context * that protect-ffi expects. Synchronous — no token round-trip. */ export function resolveLockContext(input: LockContextInput): Context { - return input instanceof LockContext ? input.identityContext : input + // Use a structural check as well as `instanceof` so a `LockContext` + // constructed in another realm (or from a duplicate module instance) is still + // resolved rather than slipping through as a raw `Context`. + return input instanceof LockContext || 'identityContext' in input + ? (input as LockContext).identityContext + : input } /** @@ -188,7 +193,10 @@ export class LockContext { return withResult( () => ({ context: this.context, - ctsToken: this.ctsToken, + // Only include `ctsToken` when one was actually set, so the + // returned shape matches the optional `ctsToken?` type rather + // than carrying an explicit `undefined`. + ...(this.ctsToken ? { ctsToken: this.ctsToken } : {}), }), (error) => ({ type: EncryptionErrorTypes.CtsTokenError, diff --git a/packages/stack/src/schema/index.ts b/packages/stack/src/schema/index.ts index 48181f12..2b2842a9 100644 --- a/packages/stack/src/schema/index.ts +++ b/packages/stack/src/schema/index.ts @@ -1,5 +1,6 @@ import { z } from 'zod' -import type { Encrypted } from '@/types' +import type { BuildableTable, Encrypted } from '@/types' +import { defaultMatchOpts } from './match-defaults' // ------------------------ // Zod schemas @@ -12,6 +13,7 @@ import type { Encrypted } from '@/types' * - `"bigint"` * - `"boolean"` * - `"date"` + * - `"timestamp"` * - `"number"` * - `"string"` * - `"json"` @@ -37,6 +39,7 @@ export const eqlCastAsEnum = z 'double', 'boolean', 'date', + 'timestamp', 'jsonb', ]) .default('text') @@ -45,7 +48,16 @@ export const eqlCastAsEnum = z * SDK-facing data types — developer-friendly aliases accepted by `dataType()`. */ export const castAsEnum = z - .enum(['bigint', 'boolean', 'date', 'number', 'string', 'json', 'text']) + .enum([ + 'bigint', + 'boolean', + 'date', + 'timestamp', + 'number', + 'string', + 'json', + 'text', + ]) .default('text') /** @@ -68,6 +80,8 @@ export function toEqlCastAs(value: CastAs): EqlCastAs { return 'boolean' case 'date': return 'date' + case 'timestamp': + return 'timestamp' case 'json': return 'jsonb' } @@ -351,17 +365,15 @@ export class EncryptedColumn { * ``` */ freeTextSearch(opts?: MatchIndexOpts) { - // Provide defaults + // Shared defaults (schema/match-defaults) — one source of truth with the + // EQL v3 domain builders. The factory returns fresh nested objects. + const defaults = defaultMatchOpts() this.indexesValue.match = { - tokenizer: opts?.tokenizer ?? { kind: 'ngram', token_length: 3 }, - token_filters: opts?.token_filters ?? [ - { - kind: 'downcase', - }, - ], - k: opts?.k ?? 6, - m: opts?.m ?? 2048, - include_original: opts?.include_original ?? true, + tokenizer: opts?.tokenizer ?? defaults.tokenizer, + token_filters: opts?.token_filters ?? defaults.token_filters, + k: opts?.k ?? defaults.k, + m: opts?.m ?? defaults.m, + include_original: opts?.include_original ?? defaults.include_original, } return this } @@ -678,7 +690,7 @@ export function encryptedField(valueName: string) { * ``` */ export function buildEncryptConfig( - ...protectTables: Array<EncryptedTable<EncryptedTableColumn>> + ...protectTables: Array<BuildableTable> ): EncryptConfig { const config: EncryptConfig = { v: 1, diff --git a/packages/stack/src/schema/match-defaults.ts b/packages/stack/src/schema/match-defaults.ts new file mode 100644 index 00000000..e1a4090b --- /dev/null +++ b/packages/stack/src/schema/match-defaults.ts @@ -0,0 +1,54 @@ +import type { MatchIndexOpts } from './index' + +/** + * Fully-resolved match-index options: every field present and non-`undefined`. + * + * `MatchIndexOpts` (the user-facing tuning input) has all fields optional — + * each is `.default(...).optional()` in the zod schema, so its inferred type is + * `T | undefined`. This type pins the BUILT/resolved shape explicitly via + * `NonNullable<...>`, which states the non-null intent directly and is robust + * regardless of `Required<>`'s subtle, `exactOptionalPropertyTypes`-dependent + * stripping semantics. + */ +export type BuiltMatchIndexOpts = { + tokenizer: NonNullable<MatchIndexOpts['tokenizer']> + token_filters: NonNullable<MatchIndexOpts['token_filters']> + k: NonNullable<MatchIndexOpts['k']> + m: NonNullable<MatchIndexOpts['m']> + include_original: NonNullable<MatchIndexOpts['include_original']> +} + +/** + * Default match-index parameters — the single source of truth shared by the + * v2 `freeTextSearch()` builder and the v3 domain builders (note + * `include_original: true`, which is the v2 builder default rather than the + * zod-schema default of `false`). + * + * This is a FACTORY (not a shared `const`) so every caller gets fresh, unaliased + * nested objects (`tokenizer`, `token_filters` and the `{ kind: 'downcase' }` + * inside it). A shared const would be shallow-copied by `{ ...DEFAULT }`, leaving + * those nested objects aliased across every column — a caller mutating one built + * config could then corrupt the defaults used by later columns. + */ +export function defaultMatchOpts(): BuiltMatchIndexOpts { + return { + tokenizer: { kind: 'ngram', token_length: 3 }, + token_filters: [{ kind: 'downcase' }], + k: 6, + m: 2048, + include_original: true, + } +} + +/** + * Deep-clone a built match block (`tokenizer` and `token_filters` are its only + * nested values) so no emitted config or stored builder state ever aliases + * another's nested objects — a caller mutating one cannot corrupt the other. + */ +export function cloneMatchOpts(opts: BuiltMatchIndexOpts): BuiltMatchIndexOpts { + return { + ...opts, + tokenizer: { ...opts.tokenizer }, + token_filters: opts.token_filters.map((f) => ({ ...f })), + } +} diff --git a/packages/stack/src/supabase/helpers.ts b/packages/stack/src/supabase/helpers.ts index 82ea2a10..5f9c2070 100644 --- a/packages/stack/src/supabase/helpers.ts +++ b/packages/stack/src/supabase/helpers.ts @@ -68,6 +68,79 @@ export function addJsonbCasts( .join(',') } +/** + * Parse a Supabase select string and add `::jsonb` casts to encrypted EQL v3 + * columns, resolving JS property names to DB column names via PostgREST + * aliasing. + * + * Input: `'id, email, createdAt'` with `{ email: 'email', createdAt: 'created_at' }` + * Output: `'id, email::jsonb, createdAt:created_at::jsonb'` + * + * - A property whose DB name differs is emitted as `prop:db_name::jsonb` + * (PostgREST rename syntax), so result rows come back keyed by the JS + * property name. + * - A DB column name used directly is cast in place (`db_name::jsonb`). + * - Tokens that already carry a cast, or contain parens/dots (functions, + * foreign tables), are left untouched — same rules as the v2 helper. + * + * Besides the rewritten select string, returns `keyToDb`: every result-row + * key this select produces for an encrypted column, mapped to its DB column + * name — including user-chosen PostgREST aliases (`ts:created_at` → rows + * keyed `ts`). The v3 builder uses it to reconstruct `Date` values on keys + * the static property↔DB map cannot see. + */ +export function addJsonbCastsV3( + columns: string, + propToDb: Record<string, string>, +): { select: string; keyToDb: Record<string, string> } { + const dbNames = new Set(Object.values(propToDb)) + const keyToDb: Record<string, string> = {} + + const select = columns + .split(',') + .map((col) => { + const trimmed = col.trim() + + if (!trimmed) return col + if (trimmed.includes('::')) return col + if (trimmed.includes('(') || trimmed.includes('.')) return col + + const leadingWhitespace = col.match(/^(\s*)/)?.[1] ?? '' + + // Already-aliased token: `alias:column` + const aliasMatch = trimmed.match( + /^([A-Za-z_][A-Za-z0-9_]*):([A-Za-z_][A-Za-z0-9_]*)$/, + ) + if (aliasMatch) { + const [, alias, name] = aliasMatch + const db = propToDb[name] ?? (dbNames.has(name) ? name : undefined) + if (db !== undefined) { + keyToDb[alias] = db + return `${leadingWhitespace}${alias}:${db}::jsonb` + } + return col + } + + const db = propToDb[trimmed] + if (db !== undefined) { + keyToDb[trimmed] = db + return db === trimmed + ? `${leadingWhitespace}${trimmed}::jsonb` + : `${leadingWhitespace}${trimmed}:${db}::jsonb` + } + + if (dbNames.has(trimmed)) { + keyToDb[trimmed] = trimmed + return `${leadingWhitespace}${trimmed}::jsonb` + } + + return col + }) + .join(',') + + return { select, keyToDb } +} + /** * Map a Supabase filter operation to a CipherStash query type. */ diff --git a/packages/stack/src/supabase/index.ts b/packages/stack/src/supabase/index.ts index 471876ff..cd9a6bb7 100644 --- a/packages/stack/src/supabase/index.ts +++ b/packages/stack/src/supabase/index.ts @@ -1,8 +1,13 @@ +import type { AnyV3Table, InferPlaintext } from '@/eql/v3' import type { EncryptedTable, EncryptedTableColumn } from '@/schema' import { EncryptedQueryBuilderImpl } from './query-builder' +import { EncryptedQueryBuilderV3Impl } from './query-builder-v3' import type { + EncryptedQueryBuilderV3, EncryptedSupabaseConfig, EncryptedSupabaseInstance, + EncryptedSupabaseV3Config, + EncryptedSupabaseV3Instance, } from './types' /** @@ -58,12 +63,68 @@ export function encryptedSupabase( } } +/** + * Create an encrypted Supabase wrapper for **EQL v3** schemas — tables + * authored with `@cipherstash/stack/eql/v3` whose columns are native + * `eql_v3.*` domains. + * + * The public surface and call shape are identical to {@link encryptedSupabase} + * (`.eq/.neq/.in/.gt/.gte/.lt/.lte/.like/.ilike/.match/.or/.not/.filter`, + * `withLockContext`, `audit`); only the schema type and the wire encoding + * differ. The same Supabase caveats carry over: the `eql_v3` schema must be + * added to the project's **Exposed schemas** and granted to the Supabase + * roles for the operators to resolve, and encrypted `ORDER BY` is + * unsupported (range *filtering* works). + * + * @example + * ```typescript + * import { Encryption } from '@cipherstash/stack' + * import { encryptedTable, types } from '@cipherstash/stack/eql/v3' + * import { encryptedSupabaseV3 } from '@cipherstash/stack/supabase' + * + * const users = encryptedTable('users', { + * email: types.TextSearch('email'), // eql_v3.text_search + * amount: types.IntegerOrd('amount'), // eql_v3.integer_ord + * }) + * + * const client = await Encryption({ schemas: [users] }) + * const es = encryptedSupabaseV3({ encryptionClient: client, supabaseClient: supabase }) + * + * await es.from('users', users).insert({ email: 'a@b.com', amount: 30 }) + * await es.from('users', users).select('id, email, amount').eq('email', 'a@b.com') + * await es.from('users', users).select('id, amount').gte('amount', 10).lte('amount', 100) + * ``` + */ +export function encryptedSupabaseV3( + config: EncryptedSupabaseV3Config, +): EncryptedSupabaseV3Instance { + const { encryptionClient, supabaseClient } = config + + return { + from< + Table extends AnyV3Table, + Row extends Record<string, unknown> = InferPlaintext<Table>, + >(tableName: string, table: Table) { + return new EncryptedQueryBuilderV3Impl<Row>( + tableName, + table, + encryptionClient, + supabaseClient, + ) as unknown as EncryptedQueryBuilderV3<Table, Row> + }, + } +} + export type { EncryptedQueryBuilder, + EncryptedQueryBuilderV3, EncryptedSupabaseConfig, EncryptedSupabaseError, EncryptedSupabaseInstance, EncryptedSupabaseResponse, + EncryptedSupabaseV3Config, + EncryptedSupabaseV3Instance, PendingOrCondition, SupabaseClientLike, + V3FilterableKeys, } from './types' diff --git a/packages/stack/src/supabase/query-builder-v3.ts b/packages/stack/src/supabase/query-builder-v3.ts new file mode 100644 index 00000000..83b28921 --- /dev/null +++ b/packages/stack/src/supabase/query-builder-v3.ts @@ -0,0 +1,325 @@ +import type { EncryptionClient } from '@/encryption' +import type { AnyV3Table } from '@/eql/v3' +import { EncryptedV3Column } from '@/eql/v3/columns' +import type { + ColumnSchema, + EncryptedTable, + EncryptedTableColumn, +} from '@/schema' +import type { BuildableQueryColumn, ScalarQueryTerm } from '@/types' +import { logger } from '@/utils/logger' +import { addJsonbCastsV3 } from './helpers' +import { + EncryptedQueryBuilderImpl, + EncryptionFailedError, +} from './query-builder' +import type { + FilterOp, + PendingOrCondition, + SupabaseClientLike, + SupabaseQueryBuilder, +} from './types' + +/** + * The subset of a v3 column builder the dialect relies on. Structural rather + * than the concrete class union so the runtime `instanceof EncryptedV3Column` + * gate and this type stay independent. + * + * Deliberately NOT `BuildableQueryColumn`'s `BuildableV3QueryableColumn` arm, + * despite the overlapping members: that type pins `isQueryable(): true`, and + * this map intentionally retains storage-only columns (whose `isQueryable()` + * is `false`) so a filter on one produces a precise error instead of passing + * through unencrypted. + */ +type V3ColumnLike = { + getName(): string + getEqlType(): string + getQueryCapabilities(): { + equality: boolean + orderAndRange: boolean + freeTextSearch: boolean + } + build(): ColumnSchema +} + +/** + * EQL v3 dialect of {@link EncryptedQueryBuilderImpl} for native `eql_v3.*` + * domain columns. The query mechanism is v2's — direct EQL operators over + * PostgREST — with four narrow forks: + * + * - **Column recognition / naming** — v3 columns are `EncryptedV3Column` + * builders and may map a JS property name to a different DB column name + * (`buildColumnKeyMap`). Filters, select casts, and mutations resolve + * property → DB name; select casts alias the DB column back to the property + * (`prop:db_name::jsonb`) so result rows keep property keys. + * - **Mutation encoding** — the raw encrypted payload object is sent (the + * `eql_v3.*` domains are `DOMAIN … AS jsonb`), not v2's `{ data: … }` + * composite wrap. + * - **Query-term encoding (INTERIM — tracked as CIP-3402)** — every filter + * operand is the FULL storage envelope from `encrypt()`, serialized as + * jsonb text. Why it is required today: each `eql_v3.*` domain CHECK + * requires the storage keys (`v`/`i`/`c` plus the domain's index terms), + * the SQL operator functions coerce their jsonb operand into the domain, + * and protect-ffi has no v3 scalar query wire shape (`encryptQuery` throws + * `EQL_V3_QUERY_UNSUPPORTED` on a v3 client) — so a term-only operand is + * impossible for EVERY domain, not just `text_search`. The full envelope + * satisfies the CHECK by construction and the operators extract the term + * they need (`eq_term`/`ord_term`/`match_term`). Caveat: operands carry a + * real ciphertext plus ALL index terms through PostgREST GET query strings + * (URL logs/proxies). Replaced by the EQL-side term-only scalar query + * envelope when it ships — see {@link encryptCollectedTerms}, the single + * swap point. + * - **`like`/`ilike`** — the v3 domains define no LIKE operator; free-text + * match is `@>` on the bloom filter. Encrypted pattern filters are emitted + * as PostgREST `cs` instead. (Match is tokenized + downcased, so `like` and + * `ilike` behave identically. For substring patterns to match, the column's + * match index should set `include_original: false` — with the default + * `true`, the full-envelope operand's bloom carries the whole pattern as an + * extra token that only matches when the pattern equals the stored value.) + * + * Decrypted rows additionally get `Date` reconstruction from the + * encrypt-config `cast_as`, mirroring the typed v3 client. + */ +export class EncryptedQueryBuilderV3Impl< + T extends Record<string, unknown> = Record<string, unknown>, +> extends EncryptedQueryBuilderImpl<T> { + private v3Table: AnyV3Table + /** JS property name → DB column name, for every encrypted column. */ + private propToDb: Record<string, string> + /** Built column schemas keyed by DB column name (for `cast_as`). */ + private columnSchemas: Record<string, ColumnSchema> + /** Column builders keyed by BOTH property name and DB name. */ + private v3Columns: Record<string, V3ColumnLike> + /** + * Result-row key → DB column name for the columns the current select + * produces, including user-chosen PostgREST aliases (`ts:created_at` keys + * rows by `ts`). Populated by {@link buildSelectString}; consumed by + * {@link postprocessDecryptedRow} so aliased date columns still get `Date` + * reconstruction. + */ + private selectKeyToDb: Record<string, string> = {} + + constructor( + tableName: string, + table: AnyV3Table, + encryptionClient: EncryptionClient, + supabaseClient: SupabaseClientLike, + ) { + super( + tableName, + // The base class only ever calls BuildableTable members on the schema + // (build / encryptModel plumbing); every v2-specific behaviour is + // overridden below. + table as unknown as EncryptedTable<EncryptedTableColumn>, + encryptionClient, + supabaseClient, + ) + + this.v3Table = table + this.propToDb = table.buildColumnKeyMap() + this.columnSchemas = table.build().columns + + this.v3Columns = {} + for (const [property, builder] of Object.entries(table.columnBuilders)) { + if (builder instanceof EncryptedV3Column) { + const col = builder as unknown as V3ColumnLike + this.v3Columns[property] = col + this.v3Columns[col.getName()] = col + } + } + + // The base class derives encrypted column names from build(), which v3 + // keys by DB name. Filters and select strings address columns by JS + // property name, so recognition must cover both. + this.encryptedColumnNames = Object.keys(this.v3Columns) + } + + // --------------------------------------------------------------------------- + // Dialect overrides + // --------------------------------------------------------------------------- + + protected override getColumnMap(): Record<string, BuildableQueryColumn> { + return this.v3Columns as unknown as Record<string, BuildableQueryColumn> + } + + protected override filterColumnName(column: string): string { + return this.propToDb[column] ?? column + } + + protected override buildSelectString(): string | null { + if (this.selectColumns === null) return null + const { select, keyToDb } = addJsonbCastsV3( + this.selectColumns, + this.propToDb, + ) + this.selectKeyToDb = keyToDb + return select + } + + /** v3 domains are plain jsonb — send the raw payload, keyed by DB name. */ + protected override transformEncryptedMutationModel( + model: Record<string, unknown>, + ): Record<string, unknown> { + const out: Record<string, unknown> = {} + for (const [key, value] of Object.entries(model)) { + out[this.propToDb[key] ?? key] = value + } + return out + } + + protected override transformEncryptedMutationModels( + models: Record<string, unknown>[], + ): Record<string, unknown>[] { + return models.map((model) => this.transformEncryptedMutationModel(model)) + } + + /** + * Encrypt every filter operand as a full storage envelope (see the class + * doc for why `encryptQuery` terms cannot be used), serialized to jsonb + * text for the PostgREST filter value. + * + * INTERIM + single swap point. The full-envelope operand is a tracked + * workaround (Linear CIP-3402), not the design: it carries a real + * decryptable ciphertext `c` plus ALL of the column's index terms, and + * PostgREST filters travel in GET query strings — so operands can land in + * URL logs, proxies, and Supabase request logs (query terms are meant to + * be index-terms-only). When the EQL term-only scalar query envelope (the + * scalar analog of `eql_v3.jsonb_query`) ships, swapping the encryption + * call inside THIS method — and its `JSON.stringify` wire encoding — must + * be the ONLY change needed: every consuming seam (filter application, + * `or`/`not` transforms, the wire-operator remap) treats the returned + * operand as an opaque, already-encoded string and is encoding-agnostic. + * Do not let operand-encoding knowledge leak out of this method. + */ + protected override async encryptCollectedTerms( + terms: ScalarQueryTerm[], + ): Promise<unknown[]> { + return Promise.all( + terms.map(async (term) => { + const column = term.column as unknown as V3ColumnLike + const queryType = term.queryType ?? 'equality' + const capabilities = column.getQueryCapabilities() + + // encrypt(null) short-circuits to null, which JSON.stringify would + // turn into the literal string "null" — a silently-wrong operand. + if (term.value == null) { + throw new Error( + `[supabase v3]: cannot encrypt a null filter value for column "${column.getName()}" — use .is('${column.getName()}', null) for NULL checks`, + ) + } + + if ( + queryType !== 'equality' && + queryType !== 'orderAndRange' && + queryType !== 'freeTextSearch' + ) { + throw new Error( + `[supabase v3]: query type "${queryType}" is not supported on scalar eql_v3 columns`, + ) + } + + if (!capabilities[queryType]) { + throw new Error( + `[supabase v3]: column "${column.getName()}" (${column.getEqlType()}) does not support ${queryType} queries — declare the column with a domain that carries that capability`, + ) + } + + const baseOp = this.encryptionClient.encrypt(term.value, { + column, + table: this.v3Table, + }) + const op = this.lockContext + ? baseOp.withLockContext(this.lockContext) + : baseOp + if (this.auditConfig) op.audit(this.auditConfig) + + const result = await op + if (result.failure) { + logger.error( + `Supabase: failed to encrypt query terms for table "${this.tableName}"`, + ) + + throw new EncryptionFailedError( + `Failed to encrypt query terms: ${result.failure.message}`, + result.failure, + ) + } + + return JSON.stringify(result.data) + }), + ) + } + + /** + * The single source of the encrypted wire-operator remap: `like`/`ilike` + * on an encrypted column become PostgREST `cs` (bloom-filter `@>`) — the + * `eql_v3.*` domains define no LIKE operator. Every pattern-bearing seam + * (`applyPatternFilter`, `notFilterOperator`, `transformOrConditions`) + * derives its operator here so they cannot drift apart. + */ + private encryptedFilterOp(op: string, wasEncrypted: boolean): string { + return wasEncrypted && (op === 'like' || op === 'ilike') ? 'cs' : op + } + + /** Encrypted pattern filters go through the bloom-filter `@>` (`cs`). */ + protected override applyPatternFilter( + q: SupabaseQueryBuilder, + column: string, + op: 'like' | 'ilike', + value: unknown, + wasEncrypted: boolean, + ): SupabaseQueryBuilder { + const wireOp = this.encryptedFilterOp(op, wasEncrypted) + if (wireOp !== op) { + return q.filter(column, wireOp, value) + } + return super.applyPatternFilter(q, column, op, value, wasEncrypted) + } + + protected override notFilterOperator( + op: FilterOp, + wasEncrypted: boolean, + ): string { + return this.encryptedFilterOp(op, wasEncrypted) + } + + protected override transformOrConditions( + conditions: PendingOrCondition[], + encryptedIndexes: Set<number>, + ): PendingOrCondition[] { + return conditions.map((cond, j) => ({ + ...cond, + column: this.filterColumnName(cond.column), + op: this.encryptedFilterOp(cond.op, encryptedIndexes.has(j)) as FilterOp, + })) + } + + /** Rebuild `Date` values from the encrypt-config `cast_as`, mirroring the + * typed v3 client's decrypt-model path. */ + protected override postprocessDecryptedRow( + row: Record<string, unknown>, + ): Record<string, unknown> { + // Row key → DB column name for every key an encrypted column can appear + // under: the select's actual keys (including user-chosen aliases like + // `ts:created_at`) plus the static property/DB names as a fallback for + // paths with no recorded select. + const keyToDb: Record<string, string> = { ...this.selectKeyToDb } + for (const [property, dbName] of Object.entries(this.propToDb)) { + keyToDb[property] ??= dbName + keyToDb[dbName] ??= dbName + } + + const out: Record<string, unknown> = { ...row } + for (const [key, dbName] of Object.entries(keyToDb)) { + // Both 'date' and 'timestamp' columns decrypt to a JS `Date`. + const castAs = this.columnSchemas[dbName]?.cast_as + if (castAs !== 'date' && castAs !== 'timestamp') continue + const value = out[key] + if (value == null || value instanceof Date) continue + if (typeof value === 'string' || typeof value === 'number') { + out[key] = new Date(value) + } + } + return out + } +} diff --git a/packages/stack/src/supabase/query-builder.ts b/packages/stack/src/supabase/query-builder.ts index 1e0483cf..5e520b0b 100644 --- a/packages/stack/src/supabase/query-builder.ts +++ b/packages/stack/src/supabase/query-builder.ts @@ -8,7 +8,7 @@ import type { AuditConfig } from '@/encryption/operations/base-operation' import type { LockContext } from '@/identity' import type { EncryptedTable, EncryptedTableColumn } from '@/schema' import { EncryptedColumn } from '@/schema' -import type { ScalarQueryTerm } from '@/types' +import type { BuildableQueryColumn, ScalarQueryTerm } from '@/types' import { logger } from '@/utils/logger' import { addJsonbCasts, @@ -46,30 +46,30 @@ import type { export class EncryptedQueryBuilderImpl< T extends Record<string, unknown> = Record<string, unknown>, > { - private tableName: string - private schema: EncryptedTable<EncryptedTableColumn> - private encryptionClient: EncryptionClient - private supabaseClient: SupabaseClientLike - private encryptedColumnNames: string[] + protected tableName: string + protected schema: EncryptedTable<EncryptedTableColumn> + protected encryptionClient: EncryptionClient + protected supabaseClient: SupabaseClientLike + protected encryptedColumnNames: string[] // Recorded operations - private mutation: MutationOp | null = null - private selectColumns: string | null = null - private selectOptions: + protected mutation: MutationOp | null = null + protected selectColumns: string | null = null + protected selectOptions: | { head?: boolean; count?: 'exact' | 'planned' | 'estimated' } | undefined = undefined - private filters: PendingFilter[] = [] - private orFilters: PendingOrFilter[] = [] - private matchFilters: PendingMatchFilter[] = [] - private notFilters: PendingNotFilter[] = [] - private rawFilters: PendingRawFilter[] = [] - private transforms: TransformOp[] = [] - private resultMode: ResultMode = 'array' - private shouldThrowOnError = false + protected filters: PendingFilter[] = [] + protected orFilters: PendingOrFilter[] = [] + protected matchFilters: PendingMatchFilter[] = [] + protected notFilters: PendingNotFilter[] = [] + protected rawFilters: PendingRawFilter[] = [] + protected transforms: TransformOp[] = [] + protected resultMode: ResultMode = 'array' + protected shouldThrowOnError = false // Encryption-specific state - private lockContext: LockContext | null = null - private auditConfig: AuditConfig | null = null + protected lockContext: LockContext | null = null + protected auditConfig: AuditConfig | null = null constructor( tableName: string, @@ -340,7 +340,7 @@ export class EncryptedQueryBuilderImpl< // Core execution // --------------------------------------------------------------------------- - private async execute(): Promise<EncryptedSupabaseResponse<T[]>> { + protected async execute(): Promise<EncryptedSupabaseResponse<T[]>> { try { logger.debug(`Supabase encrypted query on table "${this.tableName}".`) @@ -391,7 +391,7 @@ export class EncryptedQueryBuilderImpl< // Step 1: Encrypt mutation data // --------------------------------------------------------------------------- - private async encryptMutationData(): Promise< + protected async encryptMutationData(): Promise< Record<string, unknown> | Record<string, unknown>[] | null > { if (!this.mutation) return null @@ -420,7 +420,7 @@ export class EncryptedQueryBuilderImpl< ) } - return bulkModelsToEncryptedPgComposites(result.data) + return this.transformEncryptedMutationModels(result.data) } // Single model @@ -442,14 +442,33 @@ export class EncryptedQueryBuilderImpl< ) } - return modelToEncryptedPgComposites(result.data) + return this.transformEncryptedMutationModel(result.data) + } + + /** + * Encode an encrypted model for the Supabase request body. v2 wraps each + * encrypted value in the `{ data: ... }` object expected by the + * `eql_v2_encrypted` composite type. The v3 dialect overrides this — native + * `eql_v3.*` domains are plain jsonb, so the raw payload is sent instead + * (keyed by DB column name). + */ + protected transformEncryptedMutationModel( + model: Record<string, unknown>, + ): Record<string, unknown> { + return modelToEncryptedPgComposites(model) + } + + protected transformEncryptedMutationModels( + models: Record<string, unknown>[], + ): Record<string, unknown>[] { + return bulkModelsToEncryptedPgComposites(models) } // --------------------------------------------------------------------------- // Step 2: Build select string with casts // --------------------------------------------------------------------------- - private buildSelectString(): string | null { + protected buildSelectString(): string | null { if (this.selectColumns === null) return null return addJsonbCasts(this.selectColumns, this.encryptedColumnNames) } @@ -458,7 +477,7 @@ export class EncryptedQueryBuilderImpl< // Step 3: Encrypt filter values // --------------------------------------------------------------------------- - private async encryptFilterValues(): Promise<EncryptedFilterState> { + protected async encryptFilterValues(): Promise<EncryptedFilterState> { // Collect all terms that need encryption const terms: ScalarQueryTerm[] = [] const termMap: TermMapping[] = [] @@ -600,6 +619,20 @@ export class EncryptedQueryBuilderImpl< return { encryptedValues: [], termMap: [] } } + const encryptedValues = await this.encryptCollectedTerms(terms) + return { encryptedValues, termMap } + } + + /** + * Encrypt the collected filter terms, returning one encoded value per term + * (in order). v2 batch-encrypts via `encryptQuery` with the + * `composite-literal` return type — the `("json")` string the + * `eql_v2_encrypted` composite operators compare. The v3 dialect overrides + * this to produce full-envelope jsonb operands instead. + */ + protected async encryptCollectedTerms( + terms: ScalarQueryTerm[], + ): Promise<unknown[]> { // Batch encrypt all terms in one call const baseOp = this.encryptionClient.encryptQuery(terms) const op = this.lockContext @@ -619,14 +652,14 @@ export class EncryptedQueryBuilderImpl< ) } - return { encryptedValues: result.data, termMap } + return result.data } // --------------------------------------------------------------------------- // Step 4: Build and execute real Supabase query // --------------------------------------------------------------------------- - private async buildAndExecuteQuery( + protected async buildAndExecuteQuery( encryptedMutation: | Record<string, unknown> | Record<string, unknown>[] @@ -703,7 +736,7 @@ export class EncryptedQueryBuilderImpl< // Apply filters with encrypted values substituted // --------------------------------------------------------------------------- - private applyFilters( + protected applyFilters( query: SupabaseQueryBuilder, encryptedFilters: EncryptedFilterState, ): SupabaseQueryBuilder { @@ -772,36 +805,37 @@ export class EncryptedQueryBuilderImpl< }) } + const column = this.filterColumnName(f.column) + const wasEncrypted = filterValueMap.has(i) + switch (f.op) { case 'eq': - q = q.eq(f.column, value) + q = q.eq(column, value) break case 'neq': - q = q.neq(f.column, value) + q = q.neq(column, value) break case 'gt': - q = q.gt(f.column, value) + q = q.gt(column, value) break case 'gte': - q = q.gte(f.column, value) + q = q.gte(column, value) break case 'lt': - q = q.lt(f.column, value) + q = q.lt(column, value) break case 'lte': - q = q.lte(f.column, value) + q = q.lte(column, value) break case 'like': - q = q.like(f.column, value as string) - break case 'ilike': - q = q.ilike(f.column, value as string) + q = this.applyPatternFilter(q, column, f.op, value, wasEncrypted) break case 'is': - q = q.is(f.column, value) + q = q.is(column, value) break case 'in': - q = q.in(f.column, value as unknown[]) + q = q.in(column, value as unknown[]) break } } @@ -813,7 +847,7 @@ export class EncryptedQueryBuilderImpl< for (const [colName, originalValue] of Object.entries(mf.query)) { const key = `${i}:${colName}` - resolvedQuery[colName] = matchValueMap.has(key) + resolvedQuery[this.filterColumnName(colName)] = matchValueMap.has(key) ? matchValueMap.get(key) : originalValue } @@ -824,8 +858,13 @@ export class EncryptedQueryBuilderImpl< // Apply not filters for (let i = 0; i < this.notFilters.length; i++) { const nf = this.notFilters[i] - const value = notValueMap.has(i) ? notValueMap.get(i) : nf.value - q = q.not(nf.column, nf.op, value) + const wasEncrypted = notValueMap.has(i) + const value = wasEncrypted ? notValueMap.get(i) : nf.value + q = q.not( + this.filterColumnName(nf.column), + this.notFilterOperator(nf.op, wasEncrypted), + value, + ) } // Apply or filters @@ -834,34 +873,45 @@ export class EncryptedQueryBuilderImpl< if (of_.kind === 'string') { const parsed = parseOrString(of_.value) - let hasEncrypted = false + const encryptedIndexes = new Set<number>() for (let j = 0; j < parsed.length; j++) { const key = `${i}:${j}` if (orStringConditionMap.has(key)) { parsed[j] = { ...parsed[j], value: orStringConditionMap.get(key) } - hasEncrypted = true + encryptedIndexes.add(j) } } - if (hasEncrypted) { - q = q.or(rebuildOrString(parsed), { - referencedTable: of_.referencedTable, - }) + if (encryptedIndexes.size > 0) { + q = q.or( + rebuildOrString( + this.transformOrConditions(parsed, encryptedIndexes), + ), + { + referencedTable: of_.referencedTable, + }, + ) } else { q = q.or(of_.value, { referencedTable: of_.referencedTable }) } } else { // Structured: convert to string + const encryptedIndexes = new Set<number>() const conditions = of_.conditions.map((cond, j) => { const key = `${i}:${j}` if (orStructuredConditionMap.has(key)) { + encryptedIndexes.add(j) return { ...cond, value: orStructuredConditionMap.get(key) } } return cond }) - q = q.or(rebuildOrString(conditions)) + q = q.or( + rebuildOrString( + this.transformOrConditions(conditions, encryptedIndexes), + ), + ) } } @@ -869,17 +919,80 @@ export class EncryptedQueryBuilderImpl< for (let i = 0; i < this.rawFilters.length; i++) { const rf = this.rawFilters[i] const value = rawValueMap.has(i) ? rawValueMap.get(i) : rf.value - q = q.filter(rf.column, rf.operator, value) + q = q.filter(this.filterColumnName(rf.column), rf.operator, value) } return q } + // --------------------------------------------------------------------------- + // Dialect seams — every default preserves the v2 behaviour byte-for-byte. + // The v3 builder (see ./query-builder-v3) overrides these for native + // `eql_v3.*` domain columns. + // --------------------------------------------------------------------------- + + /** + * Map a filter's column name to the DB column name PostgREST must see. + * v2 schemas key columns by their DB name already, so this is the identity; + * the v3 dialect resolves a JS property name to its DB name. + */ + protected filterColumnName(column: string): string { + return column + } + + /** + * Apply a `like`/`ilike` filter. v2 relies on the `~~` operator defined on + * `eql_v2_encrypted`; the v3 dialect overrides this for encrypted columns + * because the `eql_v3.*` domains expose free-text match via `@>` + * (PostgREST `cs`) rather than a LIKE operator. + */ + protected applyPatternFilter( + q: SupabaseQueryBuilder, + column: string, + op: 'like' | 'ilike', + value: unknown, + _wasEncrypted: boolean, + ): SupabaseQueryBuilder { + return op === 'like' + ? q.like(column, value as string) + : q.ilike(column, value as string) + } + + /** + * The PostgREST operator to use for a `.not()` filter. The v3 dialect maps + * `like`/`ilike` on encrypted columns to `cs` (see applyPatternFilter). + */ + protected notFilterOperator(op: FilterOp, _wasEncrypted: boolean): string { + return op + } + + /** + * Transform `.or()` conditions before the or-string is rebuilt. The v3 + * dialect maps property names to DB names and `like`/`ilike` on encrypted + * conditions to `cs`. + */ + protected transformOrConditions( + conditions: PendingOrCondition[], + _encryptedIndexes: Set<number>, + ): PendingOrCondition[] { + return conditions + } + + /** + * Post-process a decrypted result row. The v3 dialect reconstructs `Date` + * values from the encrypt-config `cast_as`; v2 returns rows unchanged. + */ + protected postprocessDecryptedRow( + row: Record<string, unknown>, + ): Record<string, unknown> { + return row + } + // --------------------------------------------------------------------------- // Step 5: Decrypt results // --------------------------------------------------------------------------- - private async decryptResults( + protected async decryptResults( result: RawSupabaseResult, ): Promise<EncryptedSupabaseResponse<T[]>> { // If there's an error from Supabase, pass it through @@ -958,7 +1071,9 @@ export class EncryptedQueryBuilderImpl< } return { - data: decrypted.data as unknown as T[], + data: this.postprocessDecryptedRow( + decrypted.data as Record<string, unknown>, + ) as unknown as T[], error: null, count: result.count ?? null, status: result.status, @@ -997,7 +1112,9 @@ export class EncryptedQueryBuilderImpl< } return { - data: decrypted.data as unknown as T[], + data: decrypted.data.map((row) => + this.postprocessDecryptedRow(row as Record<string, unknown>), + ) as unknown as T[], error: null, count: result.count ?? null, status: result.status, @@ -1009,8 +1126,8 @@ export class EncryptedQueryBuilderImpl< // Helpers // --------------------------------------------------------------------------- - private getColumnMap(): Record<string, EncryptedColumn> { - const map: Record<string, EncryptedColumn> = {} + protected getColumnMap(): Record<string, BuildableQueryColumn> { + const map: Record<string, BuildableQueryColumn> = {} const schema = this.schema as unknown as Record<string, unknown> for (const colName of this.encryptedColumnNames) { @@ -1054,7 +1171,7 @@ type RawSupabaseResult = { statusText: string } -class EncryptionFailedError extends Error { +export class EncryptionFailedError extends Error { public encryptionError: unknown constructor(message: string, encryptionError: unknown) { diff --git a/packages/stack/src/supabase/types.ts b/packages/stack/src/supabase/types.ts index 92220e36..c24792d9 100644 --- a/packages/stack/src/supabase/types.ts +++ b/packages/stack/src/supabase/types.ts @@ -1,5 +1,6 @@ import type { EncryptionClient } from '@/encryption' import type { AuditConfig } from '@/encryption/operations/base-operation' +import type { AnyV3Table, InferPlaintext, QueryTypesForColumn } from '@/eql/v3' import type { EncryptionError } from '@/errors' import type { LockContext } from '@/identity' import type { EncryptedTable, EncryptedTableColumn } from '@/schema' @@ -20,6 +21,74 @@ export interface EncryptedSupabaseInstance { ): EncryptedQueryBuilder<T> } +// --------------------------------------------------------------------------- +// EQL v3 config & instance +// --------------------------------------------------------------------------- + +export type EncryptedSupabaseV3Config = { + encryptionClient: EncryptionClient + supabaseClient: SupabaseClientLike +} + +/** + * The column builders declared on a v3 table, recovered from the table's + * type-level `_columnType` brand. + */ +type V3ColumnsOfTable<Table> = Table extends { + readonly _columnType: infer C +} + ? C + : never + +/** + * JS property names of a v3 table's storage-only columns — those whose domain + * exposes no query capability (e.g. `types.Bool`, `types.Text`). Excluded from + * the filterable keys so a filter on one is a type error, matching the runtime + * guard in the v3 term encryption path. + */ +export type NonQueryableV3Keys<Table extends AnyV3Table> = { + [K in Extract<keyof V3ColumnsOfTable<Table>, string>]: [ + QueryTypesForColumn<V3ColumnsOfTable<Table>[K]>, + ] extends [never] + ? K + : never +}[Extract<keyof V3ColumnsOfTable<Table>, string>] + +/** + * Row keys a v3 builder accepts in filter methods: every row key except the + * table's storage-only encrypted columns. Plaintext (non-schema) columns pass + * through untouched, exactly as in v2. + */ +export type V3FilterableKeys< + Table extends AnyV3Table, + Row extends Record<string, unknown>, +> = Exclude<Extract<keyof Row, string>, NonQueryableV3Keys<Table>> + +/** + * The v3 builder type: the shared {@link EncryptedQueryBuilder} surface with + * filter methods narrowed to {@link V3FilterableKeys}. + */ +export type EncryptedQueryBuilderV3< + Table extends AnyV3Table, + Row extends Record<string, unknown>, +> = EncryptedQueryBuilder<Row, V3FilterableKeys<Table, Row> & StringKeyOf<Row>> + +export interface EncryptedSupabaseV3Instance { + /** + * `Row` defaults to exactly the table's inferred plaintext shape — NOT + * widened with an index signature. Widening would collapse + * {@link V3FilterableKeys} to `string` and silently disable the + * storage-only-column filter guard. The trade-off: with the default `Row`, + * plaintext passthrough columns (`id`, `created_at`, …) are not filterable + * or insertable at the type level — pass an explicit `Row` that includes + * them (`es.from<typeof users, UserRow>(…)`). + */ + from< + Table extends AnyV3Table, + Row extends Record<string, unknown> = InferPlaintext<Table>, + >(tableName: string, table: Table): EncryptedQueryBuilderV3<Table, Row> +} + // --------------------------------------------------------------------------- // Response // --------------------------------------------------------------------------- @@ -231,11 +300,12 @@ type StringKeyOf<T> = Extract<keyof T, string> export interface EncryptedQueryBuilder< T extends Record<string, unknown> = Record<string, unknown>, + FK extends StringKeyOf<T> = StringKeyOf<T>, > extends PromiseLike<EncryptedSupabaseResponse<T[]>> { select( columns: string, options?: { head?: boolean; count?: 'exact' | 'planned' | 'estimated' }, - ): EncryptedQueryBuilder<T> + ): EncryptedQueryBuilder<T, FK> insert( data: Partial<T> | Partial<T>[], options?: { @@ -243,11 +313,11 @@ export interface EncryptedQueryBuilder< defaultToNull?: boolean onConflict?: string }, - ): EncryptedQueryBuilder<T> + ): EncryptedQueryBuilder<T, FK> update( data: Partial<T>, options?: { count?: 'exact' | 'planned' | 'estimated' }, - ): EncryptedQueryBuilder<T> + ): EncryptedQueryBuilder<T, FK> upsert( data: Partial<T> | Partial<T>[], options?: { @@ -256,60 +326,42 @@ export interface EncryptedQueryBuilder< ignoreDuplicates?: boolean defaultToNull?: boolean }, - ): EncryptedQueryBuilder<T> + ): EncryptedQueryBuilder<T, FK> delete(options?: { count?: 'exact' | 'planned' | 'estimated' - }): EncryptedQueryBuilder<T> - eq<K extends StringKeyOf<T>>(column: K, value: T[K]): EncryptedQueryBuilder<T> - neq<K extends StringKeyOf<T>>( - column: K, - value: T[K], - ): EncryptedQueryBuilder<T> - gt<K extends StringKeyOf<T>>(column: K, value: T[K]): EncryptedQueryBuilder<T> - gte<K extends StringKeyOf<T>>( - column: K, - value: T[K], - ): EncryptedQueryBuilder<T> - lt<K extends StringKeyOf<T>>(column: K, value: T[K]): EncryptedQueryBuilder<T> - lte<K extends StringKeyOf<T>>( - column: K, - value: T[K], - ): EncryptedQueryBuilder<T> - like<K extends StringKeyOf<T>>( - column: K, - pattern: string, - ): EncryptedQueryBuilder<T> - ilike<K extends StringKeyOf<T>>( - column: K, - pattern: string, - ): EncryptedQueryBuilder<T> - is<K extends StringKeyOf<T>>( + }): EncryptedQueryBuilder<T, FK> + eq<K extends FK>(column: K, value: T[K]): EncryptedQueryBuilder<T, FK> + neq<K extends FK>(column: K, value: T[K]): EncryptedQueryBuilder<T, FK> + gt<K extends FK>(column: K, value: T[K]): EncryptedQueryBuilder<T, FK> + gte<K extends FK>(column: K, value: T[K]): EncryptedQueryBuilder<T, FK> + lt<K extends FK>(column: K, value: T[K]): EncryptedQueryBuilder<T, FK> + lte<K extends FK>(column: K, value: T[K]): EncryptedQueryBuilder<T, FK> + like<K extends FK>(column: K, pattern: string): EncryptedQueryBuilder<T, FK> + ilike<K extends FK>(column: K, pattern: string): EncryptedQueryBuilder<T, FK> + is<K extends FK>( column: K, value: null | boolean, - ): EncryptedQueryBuilder<T> - in<K extends StringKeyOf<T>>( - column: K, - values: T[K][], - ): EncryptedQueryBuilder<T> - filter<K extends StringKeyOf<T>>( + ): EncryptedQueryBuilder<T, FK> + in<K extends FK>(column: K, values: T[K][]): EncryptedQueryBuilder<T, FK> + filter<K extends FK>( column: K, operator: string, value: T[K], - ): EncryptedQueryBuilder<T> - not<K extends StringKeyOf<T>>( + ): EncryptedQueryBuilder<T, FK> + not<K extends FK>( column: K, operator: string, value: T[K], - ): EncryptedQueryBuilder<T> + ): EncryptedQueryBuilder<T, FK> or( filters: string, options?: { referencedTable?: string; foreignTable?: string }, - ): EncryptedQueryBuilder<T> + ): EncryptedQueryBuilder<T, FK> or( conditions: PendingOrCondition[], options?: { referencedTable?: string; foreignTable?: string }, - ): EncryptedQueryBuilder<T> - match(query: Partial<T>): EncryptedQueryBuilder<T> + ): EncryptedQueryBuilder<T, FK> + match(query: Partial<Pick<T, FK>>): EncryptedQueryBuilder<T, FK> order<K extends StringKeyOf<T>>( column: K, options?: { @@ -318,22 +370,22 @@ export interface EncryptedQueryBuilder< referencedTable?: string foreignTable?: string }, - ): EncryptedQueryBuilder<T> + ): EncryptedQueryBuilder<T, FK> limit( count: number, options?: { referencedTable?: string; foreignTable?: string }, - ): EncryptedQueryBuilder<T> + ): EncryptedQueryBuilder<T, FK> range( from: number, to: number, options?: { referencedTable?: string; foreignTable?: string }, - ): EncryptedQueryBuilder<T> - single(): EncryptedQueryBuilder<T> - maybeSingle(): EncryptedQueryBuilder<T> - csv(): EncryptedQueryBuilder<T> - abortSignal(signal: AbortSignal): EncryptedQueryBuilder<T> - throwOnError(): EncryptedQueryBuilder<T> + ): EncryptedQueryBuilder<T, FK> + single(): EncryptedQueryBuilder<T, FK> + maybeSingle(): EncryptedQueryBuilder<T, FK> + csv(): EncryptedQueryBuilder<T, FK> + abortSignal(signal: AbortSignal): EncryptedQueryBuilder<T, FK> + throwOnError(): EncryptedQueryBuilder<T, FK> returns<U extends Record<string, unknown>>(): EncryptedQueryBuilder<U> - withLockContext(lockContext: LockContext): EncryptedQueryBuilder<T> - audit(config: AuditConfig): EncryptedQueryBuilder<T> + withLockContext(lockContext: LockContext): EncryptedQueryBuilder<T, FK> + audit(config: AuditConfig): EncryptedQueryBuilder<T, FK> } diff --git a/packages/stack/src/types-public.ts b/packages/stack/src/types-public.ts index 929f0433..2553d3d3 100644 --- a/packages/stack/src/types-public.ts +++ b/packages/stack/src/types-public.ts @@ -14,6 +14,11 @@ // Query types (public only) export type { AuthStrategy, + BuildableColumn, + BuildableQueryColumn, + BuildableTable, + BuildableTableColumns, + BuildableV3QueryableColumn, BulkDecryptedData, BulkDecryptPayload, BulkEncryptedData, @@ -25,6 +30,7 @@ export type { DecryptionResult, Encrypted, EncryptedFields, + EncryptedFromBuildableTable, EncryptedFromSchema, EncryptedQuery, EncryptedQueryResult, diff --git a/packages/stack/src/types.ts b/packages/stack/src/types.ts index a284596b..5c5e3942 100644 --- a/packages/stack/src/types.ts +++ b/packages/stack/src/types.ts @@ -1,15 +1,17 @@ import type { AuthStrategy, Encrypted as CipherStashEncrypted, + EncryptedPayload as CipherStashEncryptedPayload, EncryptedQuery as CipherStashEncryptedQuery, + EncryptedV3Query as CipherStashEncryptedV3Query, JsPlaintext, newClient, QueryOpName, } from '@cipherstash/protect-ffi' import type { + ColumnSchema, EncryptedColumn, EncryptedField, - EncryptedTable, EncryptedTableColumn, // Imported type-only for the TSDoc {@link} references in the comments below. encryptedColumn, @@ -49,18 +51,47 @@ export type Client = Awaited<ReturnType<typeof newClient>> | undefined export type EncryptedValue = Brand<CipherStashEncrypted, 'encrypted'> /** Structural type representing encrypted data stored in the database. Always - * carries a ciphertext. See also `EncryptedValue` for branded nominal typing, + * carries a ciphertext. Covers BOTH wire formats: the EQL v2.3 payloads + * (`k: "ct"` / `k: "sv"`) and the EQL v3 payloads (flat `{v: 3, i, c, …}` + * scalars and `{v: 3, k: "sv", i, sv}` SteVec documents). Which format + * `encrypt` produces is selected by the client's + * {@link ClientConfig.eqlVersion}; `decrypt` accepts both regardless. + * v3 scalars carry no `k` discriminator, so narrow with `'k' in payload` + * before reading it. See also `EncryptedValue` for branded nominal typing, * and {@link EncryptedQuery} for the search-term shape returned by * `encryptQuery`. */ -export type Encrypted = CipherStashEncrypted +export type Encrypted = CipherStashEncryptedPayload /** Structural type representing an encrypted query term (search needle) * returned by `encryptQuery` / `encryptQueryBulk` for scalar * (`unique` / `match` / `ore`) lookups and `ste_vec_selector` JSON path - * queries. Carries no ciphertext — matched against stored values, never - * decrypted. JSON containment queries (`ste_vec_term`) return a - * storage-shaped {@link Encrypted} payload instead. */ -export type EncryptedQuery = CipherStashEncryptedQuery + * queries, plus — under `eqlVersion: 3` — the `eql_v3.jsonb_query` + * containment needle. Carries no ciphertext — matched against stored + * values, never decrypted. v2 JSON containment queries (`ste_vec_term`) + * return a storage-shaped {@link Encrypted} payload instead. */ +export type EncryptedQuery = + | CipherStashEncryptedQuery + | CipherStashEncryptedV3Query + +/** + * Plaintext values the SDK accepts for encryption. + * + * Widens the FFI's `JsPlaintext` (`string | number | boolean | + * Record<string, unknown> | JsPlaintext[]`) with `Date`. `Date` is a supported + * cast target that is omitted from the FFI's `JsPlaintext` INPUT union, but it + * serializes at the boundary via `toJSON` (ISO string), so it is accepted on the + * way in. + * + * `bigint` is intentionally NOT included: the native `@cipherstash/protect-ffi` + * build cannot marshal a JS `bigint` (V8 throws "Do not know how to serialize a + * BigInt") and rejects a `string` for a `big_int` column. The v3 int8 domains + * are therefore omitted from the SDK entirely (see `eql/v3`) until the FFI + * supports lossless bigint I/O; `bigint` returns here alongside them. + * + * When the upstream FFI `JsPlaintext` is corrected to include `Date`, the `Date` + * arm can collapse back into `JsPlaintext`. + */ +export type Plaintext = JsPlaintext | Date // --------------------------------------------------------------------------- // Client configuration @@ -127,15 +158,124 @@ export type ClientConfig = { * @see {@link AuthStrategy} */ strategy?: AuthStrategy + + /** + * The EQL wire version the client emits — one FFI client always emits + * exactly one wire format. + * + * - `2` (the protect-ffi default): payloads target the + * `eql_v2_encrypted` column type. + * - `3`: payloads target the per-capability `eql_v3` domains + * (`eql_v3.text_eq`, `eql_v3.integer_ord_ore`, `eql_v3.json`, …), + * derived from each column's `cast_as` and indexes. + * + * When omitted, {@link Encryption} auto-detects from the schema set: + * EQL v3 tables (from `@cipherstash/stack/v3`, marked by + * `buildColumnKeyMap()`) select `3`; v2 tables leave the FFI default + * (`2`) untouched. Mixing v2 and v3 tables in one client is an error — + * split them across two clients instead. + * + * `decrypt` accepts BOTH formats regardless of this setting, so v2 and + * v3 data can coexist during a migration. + * + * v3 limitation (protect-ffi 0.27): `encryptQuery` supports only JSON + * containment queries — scalar-index and selector queries throw + * `EQL_V3_QUERY_UNSUPPORTED` until a v3 scalar query wire shape exists. + */ + eqlVersion?: 2 | 3 } type AtLeastOneCsTable<T> = [T, ...T[]] +/** Structural contract for a column builder the client can consume for STORAGE + * (`encrypt`). Satisfied by v2 `EncryptedColumn` / `EncryptedField` AND v3 + * `EncryptedTextSearchColumn` — fields ARE encryptable, so this stays wide. */ +export interface BuildableColumn { + getName(): string + build(): ColumnSchema +} + +/** Structural contract for a column the client can consume for QUERIES + * (`encryptQuery` / search terms). Narrower than `BuildableColumn`: it must + * EXCLUDE non-queryable `EncryptedField` (a field has no indexes). A v2 + * `EncryptedColumn` qualifies via the nominal arm; a v3 queryable concrete + * type qualifies via the `getEqlType()` structural arm; `EncryptedField` (no + * `getEqlType`, not an `EncryptedColumn`) is rejected. */ +export interface BuildableV3QueryableColumn extends BuildableColumn { + getEqlType(): string + getQueryCapabilities(): { + equality: boolean + orderAndRange: boolean + freeTextSearch: boolean + } + isQueryable(): true +} + +export type BuildableQueryColumn = EncryptedColumn | BuildableV3QueryableColumn + +/** Structural contract for a table builder the client can consume. Satisfied by + * v2 and v3 `EncryptedTable` alike. */ +export interface BuildableTable { + tableName: string + build(): { tableName: string; columns: Record<string, ColumnSchema> } + /** + * Optional map from a model field's JS property name to its encrypt-config + * column name (the DB name). Present when the two can differ — v3 tables key + * their config by DB name (`column.getName()`) while models are written with + * JS property keys, so the model path must match by property but address the + * FFI/config by DB name. + * + * Absent on v2 tables, whose `build()` already keys columns by the JS property + * name; the model path then matches and addresses by that same key. + */ + buildColumnKeyMap?(): Record<string, string> +} + export type EncryptionClientConfig = { - schemas: AtLeastOneCsTable<EncryptedTable<EncryptedTableColumn>> + schemas: AtLeastOneCsTable<BuildableTable> config?: ClientConfig } +/** + * The literal column map of a buildable table, read from its type-level + * `_columnType` brand. Both v2 and v3 `EncryptedTable` carry this brand, so this + * recovers the literal column keys structurally. + * + * This deliberately uses the `_columnType` brand rather than `build().columns`: + * `BuildableTable.build()` is typed to return `Record<string, ColumnSchema>`, + * which erases the literal keys and would mark EVERY model field as encrypted. + * + * The fallbacks resolve to `Record<never, never>` (a no-key type), NOT `never`: + * a value typed as the bare structural `BuildableTable` carries no `_columnType` + * brand, and `keyof never` is `string | number | symbol` — which would wrongly + * mark EVERY model field as encrypted. `keyof Record<never, never>` is `never`, + * so `EncryptedFromBuildableTable` degrades gracefully to the model unchanged. + */ +export type BuildableTableColumns<T extends BuildableTable> = T extends { + readonly _columnType: infer C +} + ? C extends Record<string, unknown> + ? C + : Record<never, never> + : Record<never, never> + +/** + * Maps a plaintext model type to its encrypted form using a buildable table. + * + * Fields whose keys match a column defined in `Table` (via its `_columnType` + * brand) become `Encrypted` (`Encrypted | null` when the source field is + * nullable); all other fields retain their original types from `T`. Works for + * both v2 and v3 tables. See {@link EncryptedFromSchema} for the v2-specific + * variant retained for backward compatibility. + */ +export type EncryptedFromBuildableTable<T, Table extends BuildableTable> = { + [K in keyof T]: [K] extends [keyof BuildableTableColumns<Table>] + ? null extends T[K] + ? Encrypted | null + : Encrypted + : T[K] +} + // --------------------------------------------------------------------------- // Encrypt / decrypt operation options and results // --------------------------------------------------------------------------- @@ -147,8 +287,8 @@ export type EncryptionClientConfig = { */ export type EncryptOptions = { /** The column or nested field to encrypt into. From {@link EncryptedColumn} or {@link EncryptedField}. */ - column: EncryptedColumn | EncryptedField - table: EncryptedTable<EncryptedTableColumn> + column: BuildableColumn // storage: fields are encryptable, so stays wide + table: BuildableTable } /** Format for encrypted query/search term return values */ @@ -158,9 +298,9 @@ export type EncryptedReturnType = | 'escaped-composite-literal' export type SearchTerm = { - value: JsPlaintext - column: EncryptedColumn - table: EncryptedTable<EncryptedTableColumn> + value: Plaintext + column: BuildableQueryColumn // query: excludes non-queryable EncryptedField + table: BuildableTable returnType?: EncryptedReturnType } @@ -241,7 +381,7 @@ export type EncryptedFromSchema<T, S extends EncryptedTableColumn> = { // position-stable output. export type BulkEncryptPayload = Array<{ id?: string - plaintext: JsPlaintext | null + plaintext: Plaintext | null }> export type BulkEncryptedData = Array<{ id?: string; data: Encrypted | null }> @@ -310,8 +450,8 @@ export const queryTypeToQueryOp: Partial<Record<QueryTypeName, QueryOpName>> = { /** @internal */ export type QueryTermBase = { - column: EncryptedColumn - table: EncryptedTable<EncryptedTableColumn> + column: BuildableQueryColumn // query: excludes non-queryable EncryptedField + table: BuildableTable queryType?: QueryTypeName returnType?: EncryptedReturnType } @@ -319,5 +459,5 @@ export type QueryTermBase = { export type EncryptQueryOptions = QueryTermBase export type ScalarQueryTerm = QueryTermBase & { - value: JsPlaintext + value: Plaintext } diff --git a/packages/stack/src/wasm-inline.ts b/packages/stack/src/wasm-inline.ts index ce47233e..9fc36a4b 100644 --- a/packages/stack/src/wasm-inline.ts +++ b/packages/stack/src/wasm-inline.ts @@ -71,8 +71,6 @@ import { buildEncryptConfig, type CastAs, type EncryptConfig, - EncryptedColumn, - EncryptedField, type EncryptedTable, type EncryptedTableColumn, encryptConfigSchema, @@ -355,12 +353,26 @@ export function normalizeCastAs(config: EncryptConfig): unknown { return { ...config, tables } } -function getColumnName(col: EncryptOptions['column']): string { - if (col instanceof EncryptedColumn || col instanceof EncryptedField) { +/** + * Resolve a column's name structurally. Accepts any column builder exposing + * `getName()` — v2 `EncryptedColumn` / `EncryptedField` AND v3 column builders + * (e.g. `EncryptedTextSearchColumn`) alike — matching the structural + * `BuildableColumn` contract that `EncryptOptions.column` was widened to. + * + * An `instanceof EncryptedColumn || EncryptedField` gate would type-check after + * the widening but throw at runtime for a v3 column, breaking the type promise; + * resolving the name structurally keeps the wasm-inline encrypt entry honest. + * The `typeof` check still fails loudly for plain JS callers passing a value + * that is not a column builder. + * + * @internal exported for unit-test coverage. + */ +export function getColumnName(col: EncryptOptions['column']): string { + if (typeof col?.getName === 'function') { return col.getName() } throw new Error( - '[encryption]: opts.column must be an EncryptedColumn or EncryptedField', + '[encryption]: opts.column must be a column builder exposing getName()', ) } @@ -387,12 +399,16 @@ export function resolveStrategy(cfg: WasmClientConfig): WasmAuthStrategy { if (cfg.strategy) return cfg.strategy // No strategy → the access-key arm, where `workspaceCrn` and `accessKey` // are both required (and so present at runtime); the union widens their - // static types to `string | undefined`, hence the casts. + // static types to `string | undefined`, hence the casts. Guard at runtime + // so plain JS / Deno callers that bypass the compile-time union fail loudly + // instead of forwarding `undefined` into `AccessKeyStrategy.create`. + if (!cfg.workspaceCrn || !cfg.accessKey) { + throw new Error( + '[encryption]: `config.workspaceCrn` and `config.accessKey` are required when `config.strategy` is not provided.', + ) + } // `AccessKeyStrategy.create` takes the full workspace CRN — the region is // derived from it inside `@cipherstash/auth`, so the CRN stays the single // source of truth with no manual region split. - return AccessKeyStrategy.create( - cfg.workspaceCrn as string, - cfg.accessKey as string, - ) + return AccessKeyStrategy.create(cfg.workspaceCrn, cfg.accessKey) } diff --git a/packages/stack/tsconfig.typecheck.json b/packages/stack/tsconfig.typecheck.json new file mode 100644 index 00000000..9d06679f --- /dev/null +++ b/packages/stack/tsconfig.typecheck.json @@ -0,0 +1,4 @@ +{ + "extends": "./tsconfig.json", + "include": ["__tests__/**/*.test-d.ts"] +} diff --git a/packages/stack/tsup.config.ts b/packages/stack/tsup.config.ts index 98cd6b51..2380c8c4 100644 --- a/packages/stack/tsup.config.ts +++ b/packages/stack/tsup.config.ts @@ -15,10 +15,12 @@ export default defineConfig([ 'src/identity/index.ts', 'src/secrets/index.ts', 'src/schema/index.ts', + 'src/eql/v3/index.ts', 'src/drizzle/index.ts', 'src/dynamodb/index.ts', 'src/supabase/index.ts', 'src/encryption/index.ts', + 'src/encryption/v3.ts', 'src/errors/index.ts', ], format: ['cjs', 'esm'], diff --git a/packages/stack/vitest.config.ts b/packages/stack/vitest.config.ts index 64a1542f..c4b1da04 100644 --- a/packages/stack/vitest.config.ts +++ b/packages/stack/vitest.config.ts @@ -5,6 +5,28 @@ export default defineConfig({ resolve: { alias: { '@/': resolve(__dirname, './src') + '/', + // The installed `@cipherstash/{protect-ffi,auth}` only export `.`; their + // `/wasm-inline` subpaths (imported by `src/wasm-inline.ts`) are not + // resolvable by Vitest. Alias them to local stubs so unit tests that only + // exercise pure helpers can load the module. Tests needing real WASM + // behaviour mock these specifiers explicitly. + '@cipherstash/protect-ffi/wasm-inline': resolve( + __dirname, + './__tests__/helpers/stub-protect-ffi-wasm-inline.ts', + ), + '@cipherstash/auth/wasm-inline': resolve( + __dirname, + './__tests__/helpers/stub-auth-wasm-inline.ts', + ), + }, + }, + test: { + typecheck: { + // Scoped tsconfig keeps the 124 pre-existing wasm-inline typecheck errors + // out of scope (tracked as a follow-up). Run via the `test:types` script + // with `--typecheck.only` so the runtime suites do NOT also execute. + tsconfig: './tsconfig.typecheck.json', + include: ['__tests__/**/*.test-d.ts'], }, }, }) diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index fdc113c9..2f66a89d 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -558,8 +558,8 @@ importers: specifier: catalog:repo version: 0.40.0(@cipherstash/auth-darwin-arm64@0.40.0)(@cipherstash/auth-darwin-x64@0.40.0)(@cipherstash/auth-linux-arm64-gnu@0.40.0)(@cipherstash/auth-linux-x64-gnu@0.40.0)(@cipherstash/auth-linux-x64-musl@0.40.0)(@cipherstash/auth-win32-x64-msvc@0.40.0) '@cipherstash/protect-ffi': - specifier: 0.26.0 - version: 0.26.0 + specifier: 0.27.0 + version: 0.27.0 evlog: specifier: 1.11.0 version: 1.11.0(next@15.5.10(react-dom@19.2.3(react@19.2.3))(react@19.2.3))(react@19.2.3) @@ -588,6 +588,9 @@ importers: execa: specifier: ^9.5.2 version: 9.6.1 + fta-cli: + specifier: 3.0.0 + version: 3.0.0 json-schema-to-typescript: specifier: ^15.0.2 version: 15.0.4 @@ -945,8 +948,8 @@ packages: cpu: [arm64] os: [darwin] - '@cipherstash/protect-ffi-darwin-arm64@0.26.0': - resolution: {integrity: sha512-v2ZFgDlqHVdWEtnqxGYHGQ7gbkLVWzbB9CSEo0V3TGFhKjfh3tRsQFfZle+Fns9/1hHN0c/Q8jEvqmeRBt+TAA==} + '@cipherstash/protect-ffi-darwin-arm64@0.27.0': + resolution: {integrity: sha512-Ikh0DaqbRSsviwFAJZXHOClBMXWneCCqEbUR4YtzzGedCBnGeB3QRxoYBra/uKAkkbdgSKVncaXRJOze33bvag==} cpu: [arm64] os: [darwin] @@ -955,8 +958,8 @@ packages: cpu: [x64] os: [darwin] - '@cipherstash/protect-ffi-darwin-x64@0.26.0': - resolution: {integrity: sha512-z9pvB0v8k3S1RRzqkwMUCCNQjjJr2iY8KV3ItZOb7ykvNLd55x3gFlZKFe+zLhBesCIZASSHBFp9yIcO0GGyBA==} + '@cipherstash/protect-ffi-darwin-x64@0.27.0': + resolution: {integrity: sha512-c9DOzv5h58csIJ12wh1DXuN0RNc4PCfep0BY/9GrlJ8+ZyCmtiHXJmputX7nxIGLLlZ8aIfZFRIKjD4dJU3FoA==} cpu: [x64] os: [darwin] @@ -965,8 +968,8 @@ packages: cpu: [arm64] os: [linux] - '@cipherstash/protect-ffi-linux-arm64-gnu@0.26.0': - resolution: {integrity: sha512-IA8r5IwzCpoFUE2cB5VCCCioA8RfOIMql87SUB2DLAFShOeIACvaSwNBktwTCzLgMe5283BXqqyPNn2HzEGYGA==} + '@cipherstash/protect-ffi-linux-arm64-gnu@0.27.0': + resolution: {integrity: sha512-exZw40bjYVjv9gm2dye/agd2hVcneyOVAsNdOYDnLiw6iLiWpAWKi0ndIvOKskLLlzOFfcmGqZxGEY3rWpnnKw==} cpu: [arm64] os: [linux] @@ -975,8 +978,8 @@ packages: cpu: [x64] os: [linux] - '@cipherstash/protect-ffi-linux-x64-gnu@0.26.0': - resolution: {integrity: sha512-QZVoThJ5kjrf5icg3OJ9ctcnN0CqF6fatVTcuUOLg4nz8xb+m5dIv4WhgvCT7HnipGmALGwKWdpNlnaMrUu0cg==} + '@cipherstash/protect-ffi-linux-x64-gnu@0.27.0': + resolution: {integrity: sha512-xA8V+2VHoK0tqsQcV5KCupEQw2E5jVazsBu56dfTBUypu6y6H7gF5/zyhxFIfQNDMErpFZgfcMDuQGZ7w8B7tQ==} cpu: [x64] os: [linux] @@ -985,8 +988,8 @@ packages: cpu: [x64] os: [linux] - '@cipherstash/protect-ffi-linux-x64-musl@0.26.0': - resolution: {integrity: sha512-ji6uo8F8vKNI5lmkfEy7RX22jm79Yjg/csyVXAQcTRdwVNZdVGe01vm3f4BIXrFrGDUmHvVJWUHqChqU6z8QiA==} + '@cipherstash/protect-ffi-linux-x64-musl@0.27.0': + resolution: {integrity: sha512-EcoEXvCq4CcVMKoRIeMxEFgB8UvGfjHHl7Mohy9vkrfazOKgXcmLIuy0oKP3IhNSJuyQU1iP26KEH7XDYbn/Sg==} cpu: [x64] os: [linux] @@ -995,16 +998,16 @@ packages: cpu: [x64] os: [win32] - '@cipherstash/protect-ffi-win32-x64-msvc@0.26.0': - resolution: {integrity: sha512-1XsLN+pcGjs1O7YCGBawbaVYnJ6N2r8jIcyL0LxQOgE40P4H+CcAwwxcZT4H243g18FJGIYGIW7MVN42csPOWw==} + '@cipherstash/protect-ffi-win32-x64-msvc@0.27.0': + resolution: {integrity: sha512-G50vcDCp9c/b8WrP0Y6zw+Q3vb4sWlCFww2SDp3KY01loyLQGDadSn8Rbf24W7u/VOef1b2KqZlaCc0qeHJbGQ==} cpu: [x64] os: [win32] '@cipherstash/protect-ffi@0.23.0': resolution: {integrity: sha512-Ca8MKLrrumC561VoPDOhuUZcF8C8YenqO1Ig9hSJSRUB+jFeIJXeyn7glExsvKYWtxOx/pRub9FV8A0RyuPHMg==} - '@cipherstash/protect-ffi@0.26.0': - resolution: {integrity: sha512-UqhzMh/x/qBKhYVRiBi6V5MpHH+WiUaWQ0Wm/Q80aCrMoBNolhLWxPhiXM6zBE3tMTmH7Ge0wYIWOxFMfygMEA==} + '@cipherstash/protect-ffi@0.27.0': + resolution: {integrity: sha512-uGUb5DychOUZqe1OFI1H0zYiQkPbWAnbwW65YV6PgfJUu/Pu//EDMRJmty4SWzeNq8E6BA4t+YUPP2DEXKDnkw==} '@clack/core@1.3.0': resolution: {integrity: sha512-xJPHpAmEQUBrXSLx0gF+q5K/IyihXpsHZcha+jB+tyahsKRK3Dxo4D0coZDewHo12NhiuzC3dTtMPbm53GEAAA==} @@ -2964,8 +2967,8 @@ packages: fast-string-width@3.0.2: resolution: {integrity: sha512-gX8LrtNEI5hq8DVUfRQMbr5lpaS4nMIWV+7XEbXk2b8kiQIizgnlr12B4dA3ZEx3308ze0O4Q1R+cHts8kyUJg==} - fast-uri@3.1.3: - resolution: {integrity: sha512-i70LwGWUduXqzicKXWshooq+sWL1K3WUU5rKZNG/0i3a1OSoX3HqhH5WbWwTmqWfor4urUakGPiRQcleRZTwOg==} + fast-uri@3.1.2: + resolution: {integrity: sha512-rVjf7ArG3LTk+FS6Yw81V1DLuZl1bRbNrev6Tmd/9RaroeeRRJhAt7jg/6YFxbvAQXUCavSoZhPPj6oOx+5KjQ==} fast-wrap-ansi@0.2.0: resolution: {integrity: sha512-rLV8JHxTyhVmFYhBJuMujcrHqOT2cnO5Zxj37qROj23CP39GXubJRBUFF0z8KFK77Uc0SukZUf7JZhsVEQ6n8w==} @@ -3022,6 +3025,10 @@ packages: engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0} os: [darwin] + fta-cli@3.0.0: + resolution: {integrity: sha512-SBmoqIwbN7PLDmwmrPgjr6Z6/S9jPhNz5TCPmEVFkIaeloc/T2WXLeeXqhG1+C0UQxpOfGrC7CUb4friqbc2kQ==} + hasBin: true + function-bind@1.1.2: resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==} @@ -4452,37 +4459,37 @@ snapshots: '@cipherstash/protect-ffi-darwin-arm64@0.23.0': optional: true - '@cipherstash/protect-ffi-darwin-arm64@0.26.0': + '@cipherstash/protect-ffi-darwin-arm64@0.27.0': optional: true '@cipherstash/protect-ffi-darwin-x64@0.23.0': optional: true - '@cipherstash/protect-ffi-darwin-x64@0.26.0': + '@cipherstash/protect-ffi-darwin-x64@0.27.0': optional: true '@cipherstash/protect-ffi-linux-arm64-gnu@0.23.0': optional: true - '@cipherstash/protect-ffi-linux-arm64-gnu@0.26.0': + '@cipherstash/protect-ffi-linux-arm64-gnu@0.27.0': optional: true '@cipherstash/protect-ffi-linux-x64-gnu@0.23.0': optional: true - '@cipherstash/protect-ffi-linux-x64-gnu@0.26.0': + '@cipherstash/protect-ffi-linux-x64-gnu@0.27.0': optional: true '@cipherstash/protect-ffi-linux-x64-musl@0.23.0': optional: true - '@cipherstash/protect-ffi-linux-x64-musl@0.26.0': + '@cipherstash/protect-ffi-linux-x64-musl@0.27.0': optional: true '@cipherstash/protect-ffi-win32-x64-msvc@0.23.0': optional: true - '@cipherstash/protect-ffi-win32-x64-msvc@0.26.0': + '@cipherstash/protect-ffi-win32-x64-msvc@0.27.0': optional: true '@cipherstash/protect-ffi@0.23.0': @@ -4496,16 +4503,16 @@ snapshots: '@cipherstash/protect-ffi-linux-x64-musl': 0.23.0 '@cipherstash/protect-ffi-win32-x64-msvc': 0.23.0 - '@cipherstash/protect-ffi@0.26.0': + '@cipherstash/protect-ffi@0.27.0': dependencies: '@neon-rs/load': 0.1.82 optionalDependencies: - '@cipherstash/protect-ffi-darwin-arm64': 0.26.0 - '@cipherstash/protect-ffi-darwin-x64': 0.26.0 - '@cipherstash/protect-ffi-linux-arm64-gnu': 0.26.0 - '@cipherstash/protect-ffi-linux-x64-gnu': 0.26.0 - '@cipherstash/protect-ffi-linux-x64-musl': 0.26.0 - '@cipherstash/protect-ffi-win32-x64-msvc': 0.26.0 + '@cipherstash/protect-ffi-darwin-arm64': 0.27.0 + '@cipherstash/protect-ffi-darwin-x64': 0.27.0 + '@cipherstash/protect-ffi-linux-arm64-gnu': 0.27.0 + '@cipherstash/protect-ffi-linux-x64-gnu': 0.27.0 + '@cipherstash/protect-ffi-linux-x64-musl': 0.27.0 + '@cipherstash/protect-ffi-win32-x64-msvc': 0.27.0 '@clack/core@1.3.0': dependencies: @@ -5713,7 +5720,7 @@ snapshots: ajv@8.20.0: dependencies: fast-deep-equal: 3.1.3 - fast-uri: 3.1.3 + fast-uri: 3.1.2 json-schema-traverse: 1.0.0 require-from-string: 2.0.2 @@ -6179,7 +6186,7 @@ snapshots: dependencies: fast-string-truncated-width: 3.0.3 - fast-uri@3.1.3: {} + fast-uri@3.1.2: {} fast-wrap-ansi@0.2.0: dependencies: @@ -6242,6 +6249,8 @@ snapshots: fsevents@2.3.3: optional: true + fta-cli@3.0.0: {} + function-bind@1.1.2: {} gel@2.2.0: diff --git a/skills/stash-supabase/SKILL.md b/skills/stash-supabase/SKILL.md index 004770f2..a77f3cbe 100644 --- a/skills/stash-supabase/SKILL.md +++ b/skills/stash-supabase/SKILL.md @@ -401,6 +401,141 @@ type EncryptedSupabaseError = { - `EncryptedQueryBuilder` - `PendingOrCondition` - `SupabaseClientLike` +- `EncryptedSupabaseV3Config`, `EncryptedSupabaseV3Instance`, `EncryptedQueryBuilderV3` (EQL v3) + +## EQL v3 (native `eql_v3.*` domains) + +`encryptedSupabaseV3` is the EQL v3 counterpart of `encryptedSupabase` for +schemas authored with `@cipherstash/stack/eql/v3`. The public surface and call +shape are **identical to v2** — same filter methods, `withLockContext`, +`audit` — only the schema type and the wire encoding differ. Columns are +stored in their native `eql_v3.*` domain (a `DOMAIN … AS jsonb` with a CHECK) +instead of the v2 composite `eql_v2_encrypted`. + +### Setup + +```typescript +import { Encryption } from "@cipherstash/stack" +import { encryptedTable, types } from "@cipherstash/stack/eql/v3" +import { encryptedSupabaseV3 } from "@cipherstash/stack/supabase" + +const users = encryptedTable("users", { + email: types.TextSearch("email"), // eql_v3.text_search — eq + range + free-text + amount: types.IntegerOrd("amount"), // eql_v3.integer_ord — eq + range + joined: types.TimestampOrd("joined_at") // eql_v3.timestamp_ord — eq + range, decrypts to Date +}) + +const client = await Encryption({ schemas: [users] }) +const es = encryptedSupabaseV3({ encryptionClient: client, supabaseClient: supabase }) + +await es.from("users", users).insert({ email: "a@b.com", amount: 30 }) +await es.from("users", users).select("id, email, amount").eq("email", "a@b.com") +await es.from("users", users).select("id, amount").gte("amount", 10).lte("amount", 100) +``` + +Rows default to **exactly** the table's inferred plaintext shape. That keeps +the storage-only-column filter guard active (see below), but it means +plaintext passthrough columns (`id`, `created_at`, …) are not filterable or +insertable at the type level in the default case — pass an explicit row type +that includes them: + +```typescript +type UserRow = { id: number; email: string; amount: number; joined: Date } +const builder = es.from<typeof users, UserRow>("users", users) +builder.eq("id", 1) // ok — id is in UserRow +``` + +A JS property may map to a different DB column name +(`joined: types.TimestampOrd("joined_at")`) — filters, selects, and results +are translated automatically, and `date`/`timestamp` columns decrypt to real +`Date` objects. + +### Database schema (per-domain columns) + +Each column is declared with its native domain — the `types.*` member name +maps to the `eql_v3.<name>` domain (strip the `eql_v3.` prefix and PascalCase). +The domains use SQL-standard type names (`integer`, `smallint`, `real`, +`double`, `boolean`, `timestamp`): + +```sql +CREATE TABLE users ( + id SERIAL PRIMARY KEY, + email eql_v3.text_search, + amount eql_v3.integer_ord, + joined_at eql_v3.timestamp_ord +); +``` + +### Install EQL v3 on Supabase + +```bash +stash eql install --eql-version 3 --supabase +``` + +This installs the opclass-stripped v3 bundle (operator classes need superuser, +which Supabase does not grant) and applies the grants for the +`anon` / `authenticated` / `service_role` roles. The vendored bundle is the +`eql-3.0.0-alpha.2` release artifact; it creates two schemas — `eql_v3` (the +column domains and operators) and `eql_v3_internal` (SEM internals) — and the +installer applies the role grants to both. + +**Manual step (same class of requirement as v2's `eql_v2`):** add `eql_v3` to +the project's **Exposed schemas** (Dashboard → Settings → API → Exposed +schemas). This puts the `eql_v3` operators on PostgREST's search_path so bare +`col = term` filters resolve to the encrypted comparison. **If the schema is +not exposed, the operators do not error — they silently fall back to base +jsonb comparison and return wrong rows.** After changing the setting, verify +with a known-value round-trip: insert a row, filter for it by an encrypted +column, and assert the hit. + +Expose `eql_v3` **only** — do NOT expose `eql_v3_internal`. The internals +schema exists precisely so that only the column domains are exposed (e.g. +Supabase's Table-Builder type picker shows just the domains). It still needs — +and receives — the role grants; grants and exposure are independent. + +### v3-specific behaviour + +All envelopes (stored payloads and filter operands) are versioned `v: 3`. + +- **INTERIM — filter operands are full envelopes.** This is a workaround, not + the design (tracked as Linear **CIP-3402**). Why it is required today: every + `eql_v3.*` domain CHECK requires the storage keys (`v`/`i`/`c` plus the + domain's index terms), and the SQL operators coerce their operand into the + domain — so the adapter encrypts each filter value with the full storage + path. The call shape is unchanged. + + **Security caveat:** query terms are meant to be index-terms-only by design, + but a full-envelope operand carries a real decryptable ciphertext `c` plus + **all** of the column's index terms, and PostgREST filters travel in GET + query strings — so these envelopes can land in URL logs, intermediate + proxies, and Supabase request logs. The planned fix is an EQL-side term-only + scalar query envelope (the scalar analog of `eql_v3.jsonb_query`); once it + ships, operands stop carrying ciphertext. +- **`like`/`ilike` are emitted as PostgREST `cs`** (`@>` bloom-filter + containment) — the v3 domains define no LIKE operator. Match is tokenized + and downcased, so `like` and `ilike` behave identically; don't include `%` + wildcards in the pattern. +- **INTERIM — free-text search needs `include_original: false`** on the + column's match index + (`types.TextSearch("email").freeTextSearch({ include_original: false })`) + for substring patterns to match. With the default `include_original: true`, + the full-envelope operand's bloom carries the whole pattern as an extra + token that only matches when the pattern equals the stored value. This is a + symptom of the same full-envelope interim mechanism above and goes away with + the term-only query envelope (CIP-3402). +- **Storage-only domains are not filterable** (e.g. `types.Boolean`, + `types.Text`): a filter (including `.match()`) on one is a type error, and + always a clear runtime error. +- **Null filter values are rejected** with a pointer to `.is(column, null)` — + a null cannot be encrypted into an operand. + +### Shared caveats (identical to v2) + +- **No `ORDER BY` on encrypted columns** — operator families need superuser, + which Supabase lacks. Range *filtering* (`gte`/`lte`/…) works. (OPE index + terms that are natively orderable — btree + `ORDER BY` on Supabase — are in + active development; out of scope here.) +- **Operator visibility requires the exposed schema + grants** (above). ## Migrating an Existing Column to Encrypted